drivers/video/drm: add drm_encoder_slave.c for nouveau

The nouveau port builds it with the DRM core: dispnv04 drives its TV and TMDS encoders through the drm_i2c_encoder_* slave API. The matching drm/drm_encoder_slave.h is already in drivers/include. Assisted-by: Claude Opus 5 <noreply@anthropic.com>
drivers/include: backport Linux 4.9 bits for amdgpu and nouveau
2026-09-15 05:12:27 +03:00 · 2026-09-13 23:22:08 +03:00 · 2026-09-12 21:25:21 +00:00 · 2026-09-11 18:51:30 +00:00 · 2026-09-11 18:51:30 +00:00 · 2026-09-08 20:41:45 +00:00
114 changed files with 6151 additions and 1793 deletions
@@ -0,0 +1,54 @@
+# =============================================================================
+# Apps
+# User-facing applications, games, multimedia, UI and desktop resources
+# =============================================================================
+
+^programs/(cmm|demos|emulator|games|media|other)/.*       @KolibriOS/apps
+^contrib/(games|media|other)/.*                           @KolibriOS/apps
+^skins/.*                                                 @KolibriOS/apps
+
+
+# =============================================================================
+# System
+# Kernel, drivers, filesystems, SDK, libraries, toolchain and system utilities
+# =============================================================================
+
+^kernel/.*                                                @KolibriOS/system
+^drivers/.*                                               @KolibriOS/system
+
+^programs/(bcc32|develop|fs|hd_load|system|testing)/.*    @KolibriOS/system
+^contrib/(C_Layer|sdk|toolchain)/.*                       @KolibriOS/system
+
+# Shared system/API includes in programs/
+^programs/[^/]+\\.inc$                                    @KolibriOS/system
+
+
+# =============================================================================
+# Network
+# Network stack, network drivers, protocols, libraries and network applications
+# =============================================================================
+
+^kernel/trunk/network/.*                                  @KolibriOS/network
+
+^drivers/ethernet/.*                                      @KolibriOS/network
+^drivers/(mii|netdrv)\\.inc$                              @KolibriOS/network
+
+^programs/network/.*                                      @KolibriOS/network
+^programs/network\\.inc$                                  @KolibriOS/network
+
+^programs/develop/libraries/(http|network|kos_mbedtls)/.* @KolibriOS/network
+
+^contrib/network/.*                                       @KolibriOS/network
+
+
+# =============================================================================
+# DevOps
+# CI/CD, repository infrastructure, build system and autobuild configuration
+# =============================================================================
+
+^\\.gitea/.*                                              @KolibriOS/devops
+^_tools/.*                                                @KolibriOS/devops
+
+^\\.gitmodules$                                           @KolibriOS/devops
+^build\\.txt$                                             @KolibriOS/devops
+^tup\\.config\\.template$                                 @KolibriOS/devops
@@ -19,3 +19,38 @@
        owner: "{{ storage_user }}"
        group: "{{ storage_user }}"
        mode: preserve
+
+    # per-program binaries browsable at <version>/<lang>/data/, like on the old builds server
+    - name: Creating build tree folders
+      ansible.builtin.file:
+        path: "{{ storage_path }}/{{ version }}/{{ item | basename | regex_replace('\\.tar\\.gz$', '') }}/data"
+        state: directory
+        owner: "{{ storage_user }}"
+        group: "{{ storage_user }}"
+        mode: '0755'
+      with_fileglob: "{{ tree_artifact_path }}/*.tar.gz"
+
+    - name: Unpacking build trees
+      ansible.builtin.unarchive:
+        src: "{{ item }}"
+        dest: "{{ storage_path }}/{{ version }}/{{ item | basename | regex_replace('\\.tar\\.gz$', '') }}/data"
+        owner: "{{ storage_user }}"
+        group: "{{ storage_user }}"
+      with_fileglob: "{{ tree_artifact_path }}/*.tar.gz"
+
+    # stable URL for the newest build: <storage_path>/latest/<lang>/...
+    - name: Updating latest symlink
+      ansible.builtin.file:
+        src: "{{ version }}"
+        dest: "{{ storage_path }}/latest"
+        state: link
+        force: true
+        owner: "{{ storage_user }}"
+        group: "{{ storage_user }}"
+
+    # emulators hardcode <site root>/<lang>/data/data/kolibri.img; storage_path is the ci folder, one level under the site root
+    - name: Sending bare images to stable emulator paths
+      ansible.builtin.copy:
+        src: "{{ stable_artifact_path }}/"
+        dest: "{{ storage_path }}/../"
+        mode: preserve
@@ -162,12 +162,13 @@ jobs:
          tup init
          tup variant ${{ matrix.lang }}.config

-      # build the image for language variant
+      # build the image for language variant; keep the tup log for publishing
      - name: Build KolibriOS
        run: |
+          set -o pipefail
          export PATH=/home/autobuild/tools/win32/bin:$PATH
          source kos32-export-env-vars ${{ gitea.workspace }}
-          tup build-${{ matrix.lang }}
+          tup build-${{ matrix.lang }} 2>&1 | tee build.log

      # stamp the cache with its commit so later builds diff against it
      - name: Record cache base commit
@@ -181,15 +182,26 @@ jobs:
        id: vars
        run: echo "descr=$(git describe --tags)" >> $GITEA_OUTPUT

-      # rename build outputs to their final names so artifacts are bare files
-      - name: Rename images
+      # stage build outputs under their final names, plus distribution kit and checksums
+      - name: Prepare artifacts
        run: |
+          set -e
+          BASE="kolibrios-${{ steps.vars.outputs.descr }}-${{ matrix.lang }}"
          for ext in img iso raw; do
-            cp "build-${{ matrix.lang }}/data/kolibri.$ext" \
-               "kolibrios-${{ steps.vars.outputs.descr }}-${{ matrix.lang }}.$ext"
+            cp "build-${{ matrix.lang }}/data/kolibri.$ext" "$BASE.$ext"
          done
+          # zip: distr targets Windows/DOS users, Explorer opens it natively
+          (cd "build-${{ matrix.lang }}/data" && zip -r -9 -q "${{ gitea.workspace }}/$BASE.distr.zip" distribution_kit)
+          # whole build tree for per-program downloads; the big images ship separately
+          tar -C "build-${{ matrix.lang }}" \
+              --exclude './data/kolibri.iso' \
+              --exclude './data/kolibri.raw' \
+              --exclude './data/distribution_kit' \
+              -czf "$BASE.tree.tar.gz" .
+          sha256sum "$BASE".img "$BASE".iso "$BASE".raw "$BASE".distr.zip > "$BASE.sha256sums.txt"
+          mv build.log "$BASE.build.log"

-      #publish the three images; longer retention for the floppy image.
+      # publish the images; longer retention for the floppy image
      - name: Upload floppy image
        uses: actions/upload-artifact@v3
        with:
@@ -211,6 +223,34 @@ jobs:
          path: kolibrios-${{ steps.vars.outputs.descr }}-${{ matrix.lang }}.raw
          retention-days: 15

+      - name: Upload distribution kit
+        uses: actions/upload-artifact@v3
+        with:
+          name: kolibrios-${{ steps.vars.outputs.descr }}-${{ matrix.lang }}.distr.zip
+          path: kolibrios-${{ steps.vars.outputs.descr }}-${{ matrix.lang }}.distr.zip
+          retention-days: 30
+
+      - name: Upload checksums
+        uses: actions/upload-artifact@v3
+        with:
+          name: kolibrios-${{ steps.vars.outputs.descr }}-${{ matrix.lang }}.sha256sums.txt
+          path: kolibrios-${{ steps.vars.outputs.descr }}-${{ matrix.lang }}.sha256sums.txt
+          retention-days: 90
+
+      - name: Upload build log
+        uses: actions/upload-artifact@v3
+        with:
+          name: kolibrios-${{ steps.vars.outputs.descr }}-${{ matrix.lang }}.build.log
+          path: kolibrios-${{ steps.vars.outputs.descr }}-${{ matrix.lang }}.build.log
+          retention-days: 90
+
+      - name: Upload build tree
+        uses: actions/upload-artifact@v3
+        with:
+          name: kolibrios-${{ steps.vars.outputs.descr }}-${{ matrix.lang }}.tree.tar.gz
+          path: kolibrios-${{ steps.vars.outputs.descr }}-${{ matrix.lang }}.tree.tar.gz
+          retention-days: 15
+
  deploy:
    name: "Publish Images"
    runs-on: ubuntu-latest
@@ -235,31 +275,50 @@ jobs:
        run: |
          set -eu

-          rm -rf ./norm-artifacts
-          mkdir -p ./norm-artifacts
+          rm -rf ./norm-artifacts ./stable-artifacts ./tree-artifacts
+          mkdir -p ./norm-artifacts ./stable-artifacts ./tree-artifacts

-          find ./artifacts -type f \( \
-            -name 'kolibrios-*.img' -o \
-            -name 'kolibrios-*.iso' -o \
-            -name 'kolibrios-*.raw' \
-          \) | while read -r file; do
-            fname="$(basename "$file")"        # kolibrios-<descr>-<lang>.<ext>
-            name_without_ext="${fname%.*}"
-            lang="${name_without_ext##*-}"
+          find ./artifacts -type f -name 'kolibrios-*' | while read -r file; do
+            fname="$(basename "$file")"        # kolibrios-<descr>-<lang>.<suffix>
+            case "$fname" in
+              *.tree.tar.gz)    stem="${fname%.tree.tar.gz}";;
+              *.distr.zip)      stem="${fname%.distr.zip}";;
+              *.sha256sums.txt) stem="${fname%.sha256sums.txt}";;
+              *.build.log)      stem="${fname%.build.log}";;
+              *.img)            stem="${fname%.img}";;
+              *.iso)            stem="${fname%.iso}";;
+              *.raw)            stem="${fname%.raw}";;
+              *) continue;;
+            esac
+            lang="${stem##*-}"                 # <lang> has no dashes, <descr> may

            mkdir -p "./norm-artifacts/$lang"
-            cp "$file" "./norm-artifacts/$lang/$fname"
+            case "$fname" in
+              *.tree.tar.gz)
+                # unpacked on the server into <version>/<lang>/data/ for per-program downloads
+                cp "$file" "./tree-artifacts/$lang.tar.gz";;
+              *.sha256sums.txt)
+                cp "$file" "./norm-artifacts/$lang/sha256sums.txt";;
+              *.build.log)
+                cp "$file" "./norm-artifacts/$lang/build.log";;
+              *.img)
+                cp "$file" "./norm-artifacts/$lang/$fname"
+                # emulators (e.g. v86) hardcode <lang>/data/data/kolibri.img at the site root
+                mkdir -p "./stable-artifacts/$lang/data/data"
+                cp "$file" "./stable-artifacts/$lang/data/data/kolibri.img";;
+              *)
+                cp "$file" "./norm-artifacts/$lang/$fname";;
+            esac
          done

-          # derive the version (git describe) from an artifact name:
-          # kolibrios-<descr>-<lang>.<ext> -> <descr>
-          sample="$(find ./norm-artifacts -type f -name 'kolibrios-*' | head -n1)"
+          # derive the version (git describe) from an artifact name: kolibrios-<descr>-<lang>.iso -> <descr>
+          sample="$(find ./norm-artifacts -type f -name 'kolibrios-*.iso' | head -n1)"
          base="$(basename "${sample%.*}")"   # kolibrios-<descr>-<lang>
          version="${base%-*}"                # kolibrios-<descr>
          version="${version#kolibrios-}"     # <descr>
          echo "version=$version" >> $GITEA_OUTPUT

-          find ./norm-artifacts -type f -print
+          find ./norm-artifacts ./stable-artifacts ./tree-artifacts -type f -print

      - name: Setup SSH
        run: |
@@ -285,4 +344,6 @@ jobs:
            -e "storage_path=${{ secrets.STORAGE_PATH }}" \
            -e "version=${{ steps.normalize.outputs.version }}" \
            -e "artifact_path=${{ gitea.workspace }}/norm-artifacts" \
+            -e "stable_artifact_path=${{ gitea.workspace }}/stable-artifacts" \
+            -e "tree_artifact_path=${{ gitea.workspace }}/tree-artifacts" \
            -v
@@ -34,11 +34,10 @@ jobs:
        uses: actions/checkout@v4
        with:
          submodules: true
-          token: ${{ secrets.BOT_TOKEN }}

      - name: Bump ${{ matrix.name }} and open PR
        env:
-          TOKEN: ${{ secrets.BOT_TOKEN }}
+          TOKEN: ${{ secrets.GITEA_TOKEN }}
          API: ${{ github.api_url }}
          REPO: ${{ github.repository }}
          NAME: ${{ matrix.name }}
@@ -4,7 +4,7 @@
 	branch = main
 [submodule "programs/develop/oberon07"]
 	path = programs/develop/oberon07
-	url = https://github.com/AntKrotov/oberon-07-compiler.git
+	url = https://git.kolibrios.org/KolibriOS/oberon-07-compiler.git
 	branch = master
 [submodule "programs/cmm"]
 	path = programs/cmm
@@ -0,0 +1,68 @@
+#ifndef _ACPI_ACPI_H
+#define _ACPI_ACPI_H
+/*
+ * Minimal ACPI-CA type surface for KolibriOS.
+ *
+ * CONFIG_ACPI is never defined here, so <linux/acpi.h> compiles only its
+ * "no ACPI" branch - but that branch still mentions a handful of ACPI-CA
+ * types in the signatures of its inline stubs.  Those types are what this
+ * header provides; there is no ACPI interpreter behind them.
+ */
+#include <linux/types.h>
+
+typedef u32  acpi_status;
+typedef u32  acpi_object_type;
+typedef u64  acpi_size;
+typedef u64  acpi_io_address;
+typedef u64  acpi_physical_address;
+typedef void *acpi_handle;
+typedef char *acpi_string;
+
+#define AE_OK			((acpi_status) 0x0000)
+#define AE_ERROR		((acpi_status) 0x0001)
+#define AE_NOT_FOUND		((acpi_status) 0x0005)
+#define AE_SUPPORT		((acpi_status) 0x001D)
+
+#define ACPI_SUCCESS(a)		((a) == AE_OK)
+#define ACPI_FAILURE(a)		((a) != AE_OK)
+
+#define ACPI_TYPE_INTEGER	0x01
+#define ACPI_TYPE_STRING	0x02
+#define ACPI_TYPE_BUFFER	0x03
+#define ACPI_TYPE_PACKAGE	0x04
+#define ACPI_TYPE_ANY		0x00
+
+union acpi_object {
+	acpi_object_type type;
+	struct {
+		acpi_object_type type;
+		u64 value;
+	} integer;
+	struct {
+		acpi_object_type type;
+		u32 length;
+		char *pointer;
+	} string;
+	struct {
+		acpi_object_type type;
+		u32 length;
+		u8 *pointer;
+	} buffer;
+	struct {
+		acpi_object_type type;
+		u32 count;
+		union acpi_object *elements;
+	} package;
+};
+
+struct acpi_buffer {
+	acpi_size length;
+	void	 *pointer;
+};
+
+struct acpi_object_list {
+	u32 count;
+	union acpi_object *pointer;
+};
+
+#endif /* _ACPI_ACPI_H */
@@ -0,0 +1,13 @@
+#ifndef ACPI_BUTTON_H
+#define ACPI_BUTTON_H
+#include <linux/errno.h>
+#include <linux/notifier.h>
+/*
+ * nouveau_connector.c asks the ACPI lid device whether the panel is open
+ * before trusting an LVDS hotplug.  No ACPI here, so report "open" - the same
+ * answer the upstream !CONFIG_ACPI_BUTTON stub gives.
+ */
+static inline int acpi_lid_open(void) { return 1; }
+static inline int acpi_lid_notifier_register(struct notifier_block *nb) { return -ENODEV; }
+static inline int acpi_lid_notifier_unregister(struct notifier_block *nb) { return -ENODEV; }
+#endif
@@ -0,0 +1,40 @@
+#ifndef _ACPI_PDC_INTEL_H
+#define _ACPI_PDC_INTEL_H
+/*
+ * Intel _PDC / _OSC capability bits, included unconditionally by <asm/acpi.h>.
+ *
+ * Nothing here evaluates these - KolibriOS drivers never negotiate processor
+ * capabilities with the firmware - but the definitions have to exist for
+ * <linux/acpi.h> to be includable at all.  Values match the kernel's
+ * include/acpi/pdc_intel.h.
+ */
+
+#define ACPI_PDC_P_FFH			(0x0001)
+#define ACPI_PDC_C_C1_HALT		(0x0002)
+#define ACPI_PDC_T_FFH			(0x0004)
+#define ACPI_PDC_SMP_C1PT		(0x0008)
+#define ACPI_PDC_SMP_C2C3		(0x0010)
+#define ACPI_PDC_SMP_P_SWCOORD		(0x0020)
+#define ACPI_PDC_SMP_C_SWCOORD		(0x0040)
+#define ACPI_PDC_SMP_T_SWCOORD		(0x0080)
+#define ACPI_PDC_C_C1_FFH		(0x0100)
+#define ACPI_PDC_C_C2C3_FFH		(0x0200)
+#define ACPI_PDC_SMP_P_HWCOORD		(0x0800)
+
+#define ACPI_PDC_EST_CAPABILITY_SMP	(ACPI_PDC_SMP_C1PT | \
+					 ACPI_PDC_C_C1_HALT | \
+					 ACPI_PDC_P_FFH)
+
+#define ACPI_PDC_EST_CAPABILITY_SWSMP	(ACPI_PDC_SMP_C1PT | \
+					 ACPI_PDC_C_C1_HALT | \
+					 ACPI_PDC_SMP_P_SWCOORD | \
+					 ACPI_PDC_SMP_P_HWCOORD | \
+					 ACPI_PDC_P_FFH)
+
+#define ACPI_PDC_C_CAPABILITY_SMP	(ACPI_PDC_SMP_C2C3 | \
+					 ACPI_PDC_SMP_C1PT | \
+					 ACPI_PDC_C_C1_HALT | \
+					 ACPI_PDC_C_C1_FFH | \
+					 ACPI_PDC_C_C2C3_FFH)
+
+#endif /* _ACPI_PDC_INTEL_H */
@@ -0,0 +1,18 @@
+#ifndef __ACPI_VIDEO_H
+#define __ACPI_VIDEO_H
+/* No ACPI video extensions; nouveau_display.c only calls the register hook. */
+#include <linux/errno.h>
+
+enum acpi_backlight_type {
+	acpi_backlight_undef = -1,
+	acpi_backlight_none = 0,
+	acpi_backlight_video,
+	acpi_backlight_vendor,
+	acpi_backlight_native,
+};
+
+static inline int acpi_video_register(void) { return -ENODEV; }
+static inline void acpi_video_unregister(void) { }
+static inline enum acpi_backlight_type acpi_video_get_backlight_type(void)
+{ return acpi_backlight_vendor; }
+#endif
@@ -85,6 +85,9 @@ dma_supported(struct device *dev, u64 mask);
 extern int
 dma_set_mask(struct device *dev, u64 mask);

+extern int
+dma_set_coherent_mask(struct device *dev, u64 mask);
+
 extern int
 dma_get_cache_alignment(void);

@@ -315,6 +315,18 @@ extern bool xen_biovec_phys_mergeable(const struct bio_vec *vec1,

 #define IO_SPACE_LIMIT 0xffff

+/*
+ * Write-combining range management.  Upstream declares these under
+ * CONFIG_MTRR and provides !MTRR fallbacks from <linux/io.h>, which this tree
+ * does not carry - so they are declared unconditionally here and implemented
+ * as no-ops by each driver's kos_io.c.  arch_io_*_memtype_wc() is the 4.9
+ * spelling that came in with the PAT rework.
+ */
+extern int __must_check arch_phys_wc_add(unsigned long base, unsigned long size);
+extern void arch_phys_wc_del(int handle);
+extern int arch_io_reserve_memtype_wc(resource_size_t start, resource_size_t size);
+extern void arch_io_free_memtype_wc(resource_size_t start, resource_size_t size);
+
 #ifdef CONFIG_MTRR
 extern int __must_check arch_phys_wc_index(int handle);
 #define arch_phys_wc_index arch_phys_wc_index
@@ -359,6 +359,13 @@ struct drm_file {
 	int event_space;

 	struct mutex event_read_lock;
+
+	/*
+	 * Upstream stores the opening process here.  Nothing opens a DRM node
+	 * on this port, so it stays NULL; nouveau_drm.c only feeds it to
+	 * pid_nr() when it names a client.
+	 */
+	struct pid *pid;
 };

 /**
@@ -678,6 +685,14 @@ struct drm_device {
 	/*@} */

 	struct list_head filelist;
+	/*
+	 * Backported from Linux 4.9, which moved filelist from under
+	 * struct_mutex to its own lock.  Nothing in the 4.6 core takes it, so
+	 * it only ever serialises the driver against itself.
+	 */
+	struct mutex filelist_mutex;
+	/* Backported from Linux 4.9; unused without a real inode layer. */
+	struct inode *anon_inode;

 	/** \name Memory management */
 	/*@{ */
@@ -748,6 +763,12 @@ struct drm_device {
 //   struct drm_agp_head *agp;   /**< AGP data */

 	struct pci_dev *pdev;		/**< PCI device structure */
+	/*
+	 * Always NULL here - no platform bus.  nouveau_drm.c branches on
+	 * pdev vs platformdev when it builds the device name, and the
+	 * Tegra half of that branch is never taken.
+	 */
+	struct platform_device *platformdev;
 #ifdef __alpha__
 	struct pci_controller *hose;
 #endif
@@ -981,6 +1002,15 @@ static __inline__ int drm_pci_device_is_agp(struct drm_device *dev)
 }
 void drm_pci_agp_destroy(struct drm_device *dev);

+/*
+ * Implemented in drm_pci.c and the entry point every port's probe calls, but
+ * its upstream declaration is in the "#if 0" block below - so each main.c used
+ * to declare it by hand.  Declared here instead.
+ */
+extern int drm_get_pci_dev(struct pci_dev *pdev,
+			   const struct pci_device_id *ent,
+			   struct drm_driver *driver);
+
 #if 0
 extern int drm_pci_init(struct drm_driver *driver, struct pci_driver *pdriver);
 extern void drm_pci_exit(struct drm_driver *driver, struct pci_driver *pdriver);
@@ -152,6 +152,13 @@ struct drm_display_info {
 	u8 edid_hdmi_dc_modes;

 	u8 cea_rev;
+
+	/*
+	 * Backported from Linux 4.9: maximum TMDS clock in kHz advertised by an
+	 * HDMI sink.  drm_edid.c in this tree does not fill it in yet, so it
+	 * stays 0 and drivers fall back to their built-in limit.
+	 */
+	int max_tmds_clock;
 };

 /* data corresponds to displayid vend/prod/serial */
@@ -701,6 +708,17 @@ struct drm_crtc_funcs {
 				   const struct drm_crtc_state *state,
 				   struct drm_property *property,
 				   uint64_t *val);
+
+	/*
+	 * Backported from Linux 4.9 for the amdgpu port.  The 4.6 DRM core in
+	 * this tree never calls these; they exist so that drivers written
+	 * against the newer struct layout still compile and keep their hooks.
+	 */
+	void (*early_unregister)(struct drm_crtc *crtc);
+	int (*page_flip_target)(struct drm_crtc *crtc,
+				struct drm_framebuffer *fb,
+				struct drm_pending_vblank_event *event,
+				uint32_t flags, uint32_t target);
 };

 /**
@@ -1044,6 +1062,9 @@ struct drm_connector_funcs {
 				   const struct drm_connector_state *state,
 				   struct drm_property *property,
 				   uint64_t *val);
+
+	/* Backported from Linux 4.9 - see drm_crtc_funcs::early_unregister. */
+	void (*early_unregister)(struct drm_connector *connector);
 };

 /**
@@ -1069,6 +1090,9 @@ struct drm_encoder_funcs {
 	 * hotplugged in DRM.
 	 */
 	void (*destroy)(struct drm_encoder *encoder);
+
+	/* Backported from Linux 4.9 - see drm_crtc_funcs::early_unregister. */
+	void (*early_unregister)(struct drm_encoder *encoder);
 };

 #define DRM_CONNECTOR_MAX_ENCODER 3
@@ -1490,6 +1514,9 @@ struct drm_plane_funcs {
 				   const struct drm_plane_state *state,
 				   struct drm_property *property,
 				   uint64_t *val);
+
+	/* Backported from Linux 4.9 - see drm_crtc_funcs::early_unregister. */
+	void (*early_unregister)(struct drm_plane *plane);
 };

 enum drm_plane_type {
@@ -43,6 +43,15 @@
 #include <drm/drm_modeset_helper_vtables.h>

 extern void drm_helper_disable_unused_functions(struct drm_device *dev);
+
+/*
+ * Added after 4.6 and implemented by each port's kos_stubs.c:
+ * drm_crtc_force_disable_all() is 4.9's unload-time "turn everything off",
+ * and drm_kms_helper_is_poll_worker() is how 4.9 avoids deadlocking against
+ * its own hotplug worker - there is no such worker here.
+ */
+extern void drm_crtc_force_disable_all(struct drm_device *dev);
+extern bool drm_kms_helper_is_poll_worker(void);
 extern int drm_crtc_helper_set_config(struct drm_mode_set *set);
 extern bool drm_crtc_helper_set_mode(struct drm_crtc *crtc,
 				     struct drm_display_mode *mode,
@@ -0,0 +1,182 @@
+/*
+ * Copyright (C) 2009 Francisco Jerez.
+ * All Rights Reserved.
+ *
+ * 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 COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS 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.
+ *
+ */
+
+#ifndef __DRM_ENCODER_SLAVE_H__
+#define __DRM_ENCODER_SLAVE_H__
+
+#include <drm/drmP.h>
+#include <drm/drm_crtc.h>
+
+/**
+ * struct drm_encoder_slave_funcs - Entry points exposed by a slave encoder driver
+ * @set_config:	Initialize any encoder-specific modesetting parameters.
+ *		The meaning of the @params parameter is implementation
+ *		dependent. It will usually be a structure with DVO port
+ *		data format settings or timings. It's not required for
+ *		the new parameters to take effect until the next mode
+ *		is set.
+ *
+ * Most of its members are analogous to the function pointers in
+ * &drm_encoder_helper_funcs and they can optionally be used to
+ * initialize the latter. Connector-like methods (e.g. @get_modes and
+ * @set_property) will typically be wrapped around and only be called
+ * if the encoder is the currently selected one for the connector.
+ */
+struct drm_encoder_slave_funcs {
+	void (*set_config)(struct drm_encoder *encoder,
+			   void *params);
+
+	void (*destroy)(struct drm_encoder *encoder);
+	void (*dpms)(struct drm_encoder *encoder, int mode);
+	void (*save)(struct drm_encoder *encoder);
+	void (*restore)(struct drm_encoder *encoder);
+	bool (*mode_fixup)(struct drm_encoder *encoder,
+			   const struct drm_display_mode *mode,
+			   struct drm_display_mode *adjusted_mode);
+	int (*mode_valid)(struct drm_encoder *encoder,
+			  struct drm_display_mode *mode);
+	void (*mode_set)(struct drm_encoder *encoder,
+			 struct drm_display_mode *mode,
+			 struct drm_display_mode *adjusted_mode);
+
+	enum drm_connector_status (*detect)(struct drm_encoder *encoder,
+					    struct drm_connector *connector);
+	int (*get_modes)(struct drm_encoder *encoder,
+			 struct drm_connector *connector);
+	int (*create_resources)(struct drm_encoder *encoder,
+				 struct drm_connector *connector);
+	int (*set_property)(struct drm_encoder *encoder,
+			    struct drm_connector *connector,
+			    struct drm_property *property,
+			    uint64_t val);
+
+};
+
+/**
+ * struct drm_encoder_slave - Slave encoder struct
+ * @base: DRM encoder object.
+ * @slave_funcs: Slave encoder callbacks.
+ * @slave_priv: Slave encoder private data.
+ * @bus_priv: Bus specific data.
+ *
+ * A &drm_encoder_slave has two sets of callbacks, @slave_funcs and the
+ * ones in @base. The former are never actually called by the common
+ * CRTC code, it's just a convenience for splitting the encoder
+ * functions in an upper, GPU-specific layer and a (hopefully)
+ * GPU-agnostic lower layer: It's the GPU driver responsibility to
+ * call the slave methods when appropriate.
+ *
+ * drm_i2c_encoder_init() provides a way to get an implementation of
+ * this.
+ */
+struct drm_encoder_slave {
+	struct drm_encoder base;
+
+	const struct drm_encoder_slave_funcs *slave_funcs;
+	void *slave_priv;
+	void *bus_priv;
+};
+#define to_encoder_slave(x) container_of((x), struct drm_encoder_slave, base)
+
+int drm_i2c_encoder_init(struct drm_device *dev,
+			 struct drm_encoder_slave *encoder,
+			 struct i2c_adapter *adap,
+			 const struct i2c_board_info *info);
+
+
+/**
+ * struct drm_i2c_encoder_driver
+ *
+ * Describes a device driver for an encoder connected to the GPU
+ * through an I2C bus. In addition to the entry points in @i2c_driver
+ * an @encoder_init function should be provided. It will be called to
+ * give the driver an opportunity to allocate any per-encoder data
+ * structures and to initialize the @slave_funcs and (optionally)
+ * @slave_priv members of @encoder.
+ */
+struct drm_i2c_encoder_driver {
+	struct i2c_driver i2c_driver;
+
+	int (*encoder_init)(struct i2c_client *client,
+			    struct drm_device *dev,
+			    struct drm_encoder_slave *encoder);
+
+};
+#define to_drm_i2c_encoder_driver(x) container_of((x),			\
+						  struct drm_i2c_encoder_driver, \
+						  i2c_driver)
+
+/**
+ * drm_i2c_encoder_get_client - Get the I2C client corresponding to an encoder
+ */
+static inline struct i2c_client *drm_i2c_encoder_get_client(struct drm_encoder *encoder)
+{
+	return (struct i2c_client *)to_encoder_slave(encoder)->bus_priv;
+}
+
+/**
+ * drm_i2c_encoder_register - Register an I2C encoder driver
+ * @owner:	Module containing the driver.
+ * @driver:	Driver to be registered.
+ */
+static inline int drm_i2c_encoder_register(struct module *owner,
+					   struct drm_i2c_encoder_driver *driver)
+{
+	return i2c_register_driver(owner, &driver->i2c_driver);
+}
+
+/**
+ * drm_i2c_encoder_unregister - Unregister an I2C encoder driver
+ * @driver:	Driver to be unregistered.
+ */
+static inline void drm_i2c_encoder_unregister(struct drm_i2c_encoder_driver *driver)
+{
+	i2c_del_driver(&driver->i2c_driver);
+}
+
+void drm_i2c_encoder_destroy(struct drm_encoder *encoder);
+
+
+/*
+ * Wrapper fxns which can be plugged in to drm_encoder_helper_funcs:
+ */
+
+void drm_i2c_encoder_dpms(struct drm_encoder *encoder, int mode);
+bool drm_i2c_encoder_mode_fixup(struct drm_encoder *encoder,
+		const struct drm_display_mode *mode,
+		struct drm_display_mode *adjusted_mode);
+void drm_i2c_encoder_prepare(struct drm_encoder *encoder);
+void drm_i2c_encoder_commit(struct drm_encoder *encoder);
+void drm_i2c_encoder_mode_set(struct drm_encoder *encoder,
+		struct drm_display_mode *mode,
+		struct drm_display_mode *adjusted_mode);
+enum drm_connector_status drm_i2c_encoder_detect(struct drm_encoder *encoder,
+	    struct drm_connector *connector);
+void drm_i2c_encoder_save(struct drm_encoder *encoder);
+void drm_i2c_encoder_restore(struct drm_encoder *encoder);
+
+
+#endif
@@ -226,6 +226,14 @@ int drm_fb_helper_init(struct drm_device *dev,
 		       struct drm_fb_helper *helper, int crtc_count,
 		       int max_conn);
 void drm_fb_helper_fini(struct drm_fb_helper *helper);
+
+/*
+ * 4.9's fbdev handover.  There is no other framebuffer driver to evict on
+ * KolibriOS; implemented in each port's kos_stubs.c.
+ */
+struct apertures_struct;
+int drm_fb_helper_remove_conflicting_framebuffers(struct apertures_struct *a,
+						  const char *name, bool primary);
 int drm_fb_helper_blank(int blank, struct fb_info *info);
 int drm_fb_helper_pan_display(struct fb_var_screeninfo *var,
 			      struct fb_info *info);
@@ -0,0 +1,10 @@
+#ifndef _DRM_FOURCC_SHIM_H
+#define _DRM_FOURCC_SHIM_H
+/*
+ * The tree keeps the format list in uapi/ and the in-kernel helpers in
+ * drm_crtc.h.  Upstream drivers include <drm/drm_fourcc.h>; give them that
+ * spelling instead of patching every call site.  The guard is deliberately
+ * distinct from the uapi header's own.
+ */
+#include <uapi/drm/drm_fourcc.h>
+#endif
@@ -0,0 +1,9 @@
+#ifndef _DRM_MODE_SHIM_H
+#define _DRM_MODE_SHIM_H
+/*
+ * Same reason as drm_fourcc.h: upstream drivers spell this <drm/drm_mode.h>
+ * while the tree keeps it under uapi/.  The guard deliberately does not match
+ * the uapi header's own _DRM_MODE_H, or including this first would suppress it.
+ */
+#include <uapi/drm/drm_mode.h>
+#endif
@@ -0,0 +1,86 @@
+/*
+ * Copyright (C) 2009 Francisco Jerez.
+ * All Rights Reserved.
+ *
+ * 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 COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS 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.
+ *
+ */
+
+#ifndef __DRM_I2C_CH7006_H__
+#define __DRM_I2C_CH7006_H__
+
+/**
+ * struct ch7006_encoder_params
+ *
+ * Describes how the ch7006 is wired up with the GPU. It should be
+ * used as the @params parameter of its @set_config method.
+ *
+ * See "http://www.chrontel.com/pdf/7006.pdf" for their precise
+ * meaning.
+ */
+struct ch7006_encoder_params {
+	enum {
+		CH7006_FORMAT_RGB16 = 0,
+		CH7006_FORMAT_YCrCb24m16,
+		CH7006_FORMAT_RGB24m16,
+		CH7006_FORMAT_RGB15,
+		CH7006_FORMAT_RGB24m12C,
+		CH7006_FORMAT_RGB24m12I,
+		CH7006_FORMAT_RGB24m8,
+		CH7006_FORMAT_RGB16m8,
+		CH7006_FORMAT_RGB15m8,
+		CH7006_FORMAT_YCrCb24m8,
+	} input_format;
+
+	enum {
+		CH7006_CLOCK_SLAVE = 0,
+		CH7006_CLOCK_MASTER,
+	} clock_mode;
+
+	enum {
+		CH7006_CLOCK_EDGE_NEG = 0,
+		CH7006_CLOCK_EDGE_POS,
+	} clock_edge;
+
+	int xcm, pcm;
+
+	enum {
+		CH7006_SYNC_SLAVE = 0,
+		CH7006_SYNC_MASTER,
+	} sync_direction;
+
+	enum {
+		CH7006_SYNC_SEPARATED = 0,
+		CH7006_SYNC_EMBEDDED,
+	} sync_encoding;
+
+	enum {
+		CH7006_POUT_1_8V = 0,
+		CH7006_POUT_3_3V,
+	} pout_level;
+
+	enum {
+		CH7006_ACTIVE_HSYNC = 0,
+		CH7006_ACTIVE_DSTART,
+	} active_detect;
+};
+
+#endif
@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2010 Francisco Jerez.
+ * All Rights Reserved.
+ *
+ * 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 COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS 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.
+ *
+ */
+
+#ifndef __DRM_I2C_SIL164_H__
+#define __DRM_I2C_SIL164_H__
+
+/**
+ * struct sil164_encoder_params
+ *
+ * Describes how the sil164 is connected to the GPU. It should be used
+ * as the @params parameter of its @set_config method.
+ *
+ * See "http://www.siliconimage.com/docs/SiI-DS-0021-E-164.pdf".
+ */
+struct sil164_encoder_params {
+	enum {
+		SIL164_INPUT_EDGE_FALLING = 0,
+		SIL164_INPUT_EDGE_RISING
+	} input_edge;
+
+	enum {
+		SIL164_INPUT_WIDTH_12BIT = 0,
+		SIL164_INPUT_WIDTH_24BIT
+	} input_width;
+
+	enum {
+		SIL164_INPUT_SINGLE_EDGE = 0,
+		SIL164_INPUT_DUAL_EDGE
+	} input_dual;
+
+	enum {
+		SIL164_PLL_FILTER_ON = 0,
+		SIL164_PLL_FILTER_OFF,
+	} pll_filter;
+
+	int input_skew; /** < Allowed range [-4, 3], use 0 for no de-skew. */
+	int duallink_skew; /** < Allowed range [-4, 3]. */
+};
+
+#endif
@@ -257,6 +257,15 @@ struct ttm_buffer_object {
 	struct reservation_object *resv;
 	struct reservation_object ttm_resv;
 	struct mutex wu_mutex;
+
+	/*
+	 * Backported from Linux 4.9: fence of the last accelerated move, kept
+	 * outside the reservation object so a pipelined eviction can be waited
+	 * on without blocking other users.  The 4.6 TTM in this tree still
+	 * waits synchronously, so the core leaves this NULL; amdgpu sets and
+	 * checks it on its own paths.
+	 */
+	struct fence *moving;
 };

 /**
@@ -434,8 +434,20 @@ struct ttm_bo_driver {
 	 */
 	int (*io_mem_reserve)(struct ttm_bo_device *bdev, struct ttm_mem_reg *mem);
 	void (*io_mem_free)(struct ttm_bo_device *bdev, struct ttm_mem_reg *mem);
+
+	/*
+	 * Backported from Linux 4.9 for the amdgpu port.  The 4.6 TTM in this
+	 * tree does not consult these hooks - it always uses the default LRU
+	 * placement - but drivers written against 4.9 still populate them.
+	 */
+	void (*lru_removal)(struct ttm_buffer_object *bo);
+	struct list_head *(*lru_tail)(struct ttm_buffer_object *bo);
+	struct list_head *(*swap_lru_tail)(struct ttm_buffer_object *bo);
 };

+struct list_head *ttm_bo_default_lru_tail(struct ttm_buffer_object *bo);
+struct list_head *ttm_bo_default_swap_lru_tail(struct ttm_buffer_object *bo);
+
 /**
 * struct ttm_bo_global_ref - Argument to initialize a struct ttm_bo_global.
 */
@@ -0,0 +1,21 @@
+#ifndef _LINUX_CLK_H
+#define _LINUX_CLK_H
+/*
+ * Tegra-only.  nvif/os.h pulls this in unconditionally, but the only nouveau
+ * code that calls a clk_* helper is nvkm/engine/device/tegra.c, which this
+ * port does not build.
+ */
+#include <linux/errno.h>
+#include <linux/err.h>
+
+struct clk;
+struct device;
+
+static inline struct clk *clk_get(struct device *dev, const char *id)
+{ return ERR_PTR(-ENOENT); }
+static inline void clk_put(struct clk *clk) { }
+static inline int clk_prepare_enable(struct clk *clk) { return -ENOSYS; }
+static inline void clk_disable_unprepare(struct clk *clk) { }
+static inline unsigned long clk_get_rate(struct clk *clk) { return 0; }
+static inline int clk_set_rate(struct clk *clk, unsigned long rate) { return -ENOSYS; }
+#endif
@@ -0,0 +1,14 @@
+#ifndef _LINUX_CONSOLE_H
+#define _LINUX_CONSOLE_H
+/* KolibriOS has no VT console layer; the fbdev handover hooks are no-ops. */
+#define CON_PRINTBUFFER	(1)
+#define CON_CONSDEV	(2)
+#define CON_ENABLED	(4)
+#define CON_BOOT	(8)
+#define CON_ANYTIME	(16)
+#define CON_BRL		(32)
+
+static inline void console_lock(void)   { }
+static inline void console_unlock(void) { }
+static inline int  console_trylock(void) { return 1; }
+#endif
@@ -0,0 +1,7 @@
+#ifndef _LINUX_DEBUGFS_H
+#define _LINUX_DEBUGFS_H
+/* No debugfs in KolibriOS - CONFIG_DEBUG_FS is never defined. */
+#include <linux/types.h>
+struct dentry;
+struct file_operations;
+#endif
@@ -31,6 +31,12 @@ enum probe_type {

 struct device_driver {
 	const char		*name;
+	/*
+	 * Restored for drm_encoder_slave.c, which pins the slave encoder's
+	 * module around a bind.  Nothing is ever bound on this port, so it
+	 * stays NULL and try_module_get()/module_put() are no-ops.
+	 */
+	struct module		*owner;
 	const char		*mod_name;	/* used for built-in modules */

 	bool suppress_bind_attrs;	/* disables bind/unbind via sysfs */
@@ -126,5 +132,28 @@ static inline __printf(2, 3)
 void dev_notice(const struct device *dev, const char *fmt, ...)
 {}

+/*
+ * sysfs attribute types.  KolibriOS has no sysfs, so nothing ever walks these
+ * tables - but drivers still declare them at file scope, so the layout has to
+ * exist.  Matches the upstream definitions field for field.
+ */
+#include <linux/sysfs.h>
+
+struct device_attribute {
+	struct attribute attr;
+	ssize_t (*show)(struct device *dev, struct device_attribute *attr,
+			char *buf);
+	ssize_t (*store)(struct device *dev, struct device_attribute *attr,
+			 const char *buf, size_t count);
+};
+
+#define __ATTR(_name, _mode, _show, _store) {				\
+	.attr  = { .name = __stringify(_name), .mode = (_mode) },	\
+	.show  = _show,							\
+	.store = _store,						\
+}
+
+#define DEVICE_ATTR(_name, _mode, _show, _store) \
+	struct device_attribute dev_attr_##_name = __ATTR(_name, _mode, _show, _store)

 #endif /* _DEVICE_H_ */
@@ -131,6 +131,12 @@ struct dma_buf {
 	const char *exp_name;
 	struct list_head list_node;
 	void *priv;
+	/*
+	 * Upstream keeps the exporter's reservation object here.  No dma-buf
+	 * is ever created on this port, so nouveau_prime.c's import path is
+	 * dead code - but it dereferences the field, so it has to exist.
+	 */
+	struct reservation_object *resv;
 };

 /**
@@ -0,0 +1,7 @@
+#ifndef _LINUX_EFI_H
+#define _LINUX_EFI_H
+/* KolibriOS boots via BIOS only; amdgpu only tests efi_enabled(). */
+#define EFI_BOOT		0
+#define EFI_RUNTIME_SERVICES	1
+static inline bool efi_enabled(int feature) { return false; }
+#endif
@@ -470,7 +470,12 @@ struct fb_info {
 	struct fb_fix_screeninfo fix;	/* Current fix */
 	struct fb_monspecs monspecs;	/* Current Monitor specs */
 //   struct work_struct queue;   /* Framebuffer event queue */
-//   struct fb_pixmap pixmap;    /* Image hardware mapper */
+	/*
+	 * Restored for nouveau, which sets pixmap.buf_align after
+	 * drm_fb_helper_initial_config().  Nothing on this port consumes the
+	 * field - there is no fbcon - but the assignment has to compile.
+	 */
+	struct fb_pixmap pixmap;    /* Image hardware mapper */
 //   struct fb_pixmap sprite;    /* Cursor hardware mapper */
 //   struct fb_cmap cmap;        /* Current cmap */
 	struct list_head modelist;      /* mode list */
@@ -0,0 +1,83 @@
+/*
+ * fence-array: aggregates fence to be waited together
+ *
+ * Copyright (C) 2016 Collabora Ltd
+ * Copyright (C) 2016 Advanced Micro Devices, Inc.
+ * Authors:
+ *	Gustavo Padovan <gustavo@padovan.org>
+ *	Christian König <christian.koenig@amd.com>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ */
+
+#ifndef __LINUX_FENCE_ARRAY_H
+#define __LINUX_FENCE_ARRAY_H
+
+#include <linux/fence.h>
+
+/**
+ * struct fence_array_cb - callback helper for fence array
+ * @cb: fence callback structure for signaling
+ * @array: reference to the parent fence array object
+ */
+struct fence_array_cb {
+	struct fence_cb cb;
+	struct fence_array *array;
+};
+
+/**
+ * struct fence_array - fence to represent an array of fences
+ * @base: fence base class
+ * @lock: spinlock for fence handling
+ * @num_fences: number of fences in the array
+ * @num_pending: fences in the array still pending
+ * @fences: array of the fences
+ */
+struct fence_array {
+	struct fence base;
+
+	spinlock_t lock;
+	unsigned num_fences;
+	atomic_t num_pending;
+	struct fence **fences;
+};
+
+extern const struct fence_ops fence_array_ops;
+
+/**
+ * fence_is_array - check if a fence is from the array subsclass
+ *
+ * Return true if it is a fence_array and false otherwise.
+ */
+static inline bool fence_is_array(struct fence *fence)
+{
+	return fence->ops == &fence_array_ops;
+}
+
+/**
+ * to_fence_array - cast a fence to a fence_array
+ * @fence: fence to cast to a fence_array
+ *
+ * Returns NULL if the fence is not a fence_array,
+ * or the fence_array otherwise.
+ */
+static inline struct fence_array *to_fence_array(struct fence *fence)
+{
+	if (fence->ops != &fence_array_ops)
+		return NULL;
+
+	return container_of(fence, struct fence_array, base);
+}
+
+struct fence_array *fence_array_create(int num_fences, struct fence **fences,
+				       u64 context, unsigned seqno,
+				       bool signal_on_any);
+
+#endif /* __LINUX_FENCE_ARRAY_H */
@@ -0,0 +1,35 @@
+#ifndef _LINUX_HRTIMER_H
+#define _LINUX_HRTIMER_H
+/*
+ * amdgpu_mode.h only embeds a struct hrtimer in the virtual-DCE crtc and never
+ * arms it on this port, so a structural stub is enough.
+ */
+#include <linux/types.h>
+#include <linux/ktime.h>
+
+enum hrtimer_restart { HRTIMER_NORESTART, HRTIMER_RESTART };
+enum hrtimer_mode {
+	HRTIMER_MODE_ABS	= 0x0,
+	HRTIMER_MODE_REL	= 0x1,
+	HRTIMER_MODE_PINNED	= 0x2,
+};
+enum hrtimer_base_type { HRTIMER_BASE_MONOTONIC, HRTIMER_MAX_CLOCK_BASES };
+
+struct hrtimer {
+	ktime_t	_softexpires;
+	enum hrtimer_restart (*function)(struct hrtimer *);
+	int	state;
+};
+
+static inline void hrtimer_init(struct hrtimer *timer, int which, enum hrtimer_mode mode)
+	{ timer->function = NULL; timer->state = 0; }
+static inline int  hrtimer_start(struct hrtimer *t, ktime_t tim, enum hrtimer_mode m) { return 0; }
+static inline int  hrtimer_cancel(struct hrtimer *t) { return 0; }
+static inline int  hrtimer_try_to_cancel(struct hrtimer *t) { return 0; }
+static inline bool hrtimer_active(const struct hrtimer *t) { return false; }
+static inline void hrtimer_start_range_ns(struct hrtimer *t, ktime_t tim,
+					  u64 range_ns, enum hrtimer_mode m) { }
+
+/* Sleeps through the DDK's delay(); see the driver's kos_* glue. */
+extern int schedule_hrtimeout(ktime_t *expires, const enum hrtimer_mode mode);
+#endif
@@ -0,0 +1,27 @@
+#ifndef _LINUX_HWMON_SYSFS_H
+#define _LINUX_HWMON_SYSFS_H
+/* sysfs is absent; amdgpu_pm.c's hwmon attributes are compiled out to stubs. */
+#include <linux/device.h>
+
+struct sensor_device_attribute {
+	struct device_attribute dev_attr;
+	int index;
+};
+#define to_sensor_dev_attr(_dev_attr) \
+	container_of(_dev_attr, struct sensor_device_attribute, dev_attr)
+
+#define SENSOR_ATTR(_name, _mode, _show, _store, _index) \
+	{ .dev_attr = __ATTR(_name, _mode, _show, _store), .index = _index }
+
+#define SENSOR_DEVICE_ATTR(_name, _mode, _show, _store, _index) \
+	struct sensor_device_attribute sensor_dev_attr_##_name = \
+		SENSOR_ATTR(_name, _mode, _show, _store, _index)
+
+struct sensor_device_attribute_2 {
+	struct device_attribute dev_attr;
+	u8 index;
+	u8 nr;
+};
+#define to_sensor_dev_attr_2(_dev_attr) \
+	container_of(_dev_attr, struct sensor_device_attribute_2, dev_attr)
+#endif
@@ -52,6 +52,19 @@ struct i2c_board_info;
 extern int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs,
 			int num);

+/*
+ * Declared here rather than left implicit: i2c-core.c defines them, and
+ * nouveau reaches all three - i2c_new_device()/i2c_unregister_device() from
+ * nvkm/subdev/therm/ic.c, i2c_register_driver() through the i2c_add_driver()
+ * inline below.
+ */
+struct module;
+extern int i2c_register_driver(struct module *owner, struct i2c_driver *driver);
+extern void i2c_del_driver(struct i2c_driver *driver);
+extern struct i2c_client *i2c_new_device(struct i2c_adapter *adap,
+					 struct i2c_board_info const *info);
+extern void i2c_unregister_device(struct i2c_client *client);
+
 /**
 * struct i2c_driver - represent an I2C device driver
 * @class: What kind of i2c device we instantiate (for detect)
@@ -114,11 +127,18 @@ struct i2c_driver {
 	 */
 	int (*command)(struct i2c_client *client, unsigned int cmd, void *arg);

-//	struct device_driver driver;
+	/*
+	 * Restored for nouveau: nvkm/subdev/therm/ic.c reaches the bound
+	 * driver through to_i2c_driver(client->dev.driver)->detect().  There
+	 * is no driver-model binding on this port, so dev.driver is always
+	 * NULL and the probe short-circuits - but the fields have to exist
+	 * for to_i2c_driver() to compile.
+	 */
+	struct device_driver driver;
 	const struct i2c_device_id *id_table;

 	/* Device detection callback for automatic device creation */
-//	int (*detect)(struct i2c_client *, struct i2c_board_info *);
+	int (*detect)(struct i2c_client *, struct i2c_board_info *);
 	const unsigned short *address_list;
 	struct list_head clients;
 };
@@ -5,6 +5,18 @@
 #include <linux/kernel.h>
 #include <linux/bitops.h>
 #include <linux/irqreturn.h>
+
+/*
+ * Taking an interrupt outside drm_irq_install().  nouveau's nvkm_pci_init()
+ * does exactly that, so the driver supplies request_irq()/free_irq() over
+ * AttachIntHandler(); the signatures are upstream's.
+ */
+typedef irqreturn_t (*irq_handler_t)(int irq, void *dev_id);
+
+extern int request_irq(unsigned int irq, irq_handler_t handler,
+		       unsigned long flags, const char *name, void *dev_id);
+extern void free_irq(unsigned int irq, void *dev_id);
+
 #include <linux/kref.h>
 #include <linux/atomic.h>
 /*
@@ -0,0 +1,37 @@
+#ifndef _LINUX_IOMMU_H
+#define _LINUX_IOMMU_H
+/*
+ * No IOMMU on this port.  nvif/os.h includes it unconditionally; the only user
+ * is the Tegra SMMU path in nvkm/engine/device/tegra.c, which is not built.
+ */
+#include <linux/errno.h>
+#include <linux/types.h>
+
+#define IOMMU_READ	(1 << 0)
+#define IOMMU_WRITE	(1 << 1)
+#define IOMMU_CACHE	(1 << 2)
+
+struct device;
+struct iommu_domain;
+struct iommu_group;
+
+struct iommu_domain_geometry {
+	dma_addr_t aperture_start;
+	dma_addr_t aperture_end;
+	bool force_aperture;
+};
+
+static inline struct iommu_domain *iommu_domain_alloc(void *bus) { return NULL; }
+static inline void iommu_domain_free(struct iommu_domain *d) { }
+static inline int iommu_attach_device(struct iommu_domain *d, struct device *dev)
+{ return -ENODEV; }
+static inline void iommu_detach_device(struct iommu_domain *d, struct device *dev) { }
+static inline struct iommu_group *iommu_group_get(struct device *dev) { return NULL; }
+static inline int iommu_map(struct iommu_domain *domain, unsigned long iova,
+			    phys_addr_t paddr, size_t size, int prot)
+{ return -ENODEV; }
+static inline size_t iommu_unmap(struct iommu_domain *domain, unsigned long iova,
+				 size_t size)
+{ return 0; }
+static inline void iommu_group_put(struct iommu_group *g) { }
+#endif
@@ -0,0 +1,27 @@
+#ifndef _LINUX_IRQ_H
+#define _LINUX_IRQ_H
+/*
+ * KolibriOS has no irq_domain layer.  amdgpu_irq.c is patched to dispatch IH
+ * ring entries straight to the registered amdgpu_irq_src, so only the types it
+ * still mentions need to exist.
+ */
+#include <linux/types.h>
+
+struct irq_data {
+	unsigned int	 irq;
+	unsigned long	 hwirq;
+	void		*chip_data;
+};
+
+struct irq_chip {
+	const char	*name;
+	void		(*irq_mask)(struct irq_data *data);
+	void		(*irq_unmask)(struct irq_data *data);
+};
+
+static inline void *irq_data_get_irq_chip_data(struct irq_data *d)
+{
+	return d ? d->chip_data : NULL;
+}
+static inline void handle_simple_irq(void) { }
+#endif
@@ -0,0 +1,41 @@
+#ifndef _LINUX_IRQDOMAIN_H
+#define _LINUX_IRQDOMAIN_H
+/*
+ * KolibriOS has no irq domain layer.
+ *
+ * amdgpu builds a linear domain purely so that a *different* driver (the ACP
+ * audio co-processor) can receive GPU interrupts by Linux irq number.  ACP is
+ * not part of this port, so no mapping is ever created: adev->irq.virq[] stays
+ * zero and amdgpu_irq_dispatch() always takes its direct-call branch.
+ *
+ * These declarations therefore exist to keep the domain setup compiling and
+ * succeeding; the implementations in the driver's kos_stubs.c do nothing.
+ */
+#include <linux/types.h>
+#include <linux/irq.h>
+
+typedef unsigned long irq_hw_number_t;
+
+struct irq_domain;
+struct device_node;
+
+struct irq_domain_ops {
+	int  (*map)(struct irq_domain *d, unsigned int virq, irq_hw_number_t hw);
+	void (*unmap)(struct irq_domain *d, unsigned int virq);
+	int  (*xlate)(struct irq_domain *d, struct device_node *node,
+		      const u32 *intspec, unsigned int intsize,
+		      unsigned long *out_hwirq, unsigned int *out_type);
+};
+
+struct irq_domain *irq_domain_add_linear(struct device_node *of_node,
+					 unsigned int size,
+					 const struct irq_domain_ops *ops,
+					 void *host_data);
+void	 irq_domain_remove(struct irq_domain *domain);
+unsigned int irq_create_mapping(struct irq_domain *domain, irq_hw_number_t hwirq);
+unsigned int irq_find_mapping(struct irq_domain *domain, irq_hw_number_t hwirq);
+int	 generic_handle_irq(unsigned int irq);
+void	 irq_set_chip_and_handler(unsigned int irq, struct irq_chip *chip,
+				  void (*handle)(void));
+
+#endif /* _LINUX_IRQDOMAIN_H */
@@ -684,7 +684,20 @@ typedef union
 	u64 raw;
 }evhandle_t;

-struct vm_area_struct {};
+/*
+ * KolibriOS has no user address space that drivers can map into, so these are
+ * placeholders.  The fields exist because the mmap/userptr entry points of the
+ * ported DRM drivers reference them; those paths are never reached, since no
+ * ioctl surface is exposed to user code.
+ */
+struct vm_area_struct {
+	unsigned long	 vm_start;
+	unsigned long	 vm_end;
+	unsigned long	 vm_pgoff;
+	unsigned long	 vm_flags;
+	struct file	*vm_file;
+	void		*vm_private_data;
+};
 struct address_space {};

 #define in_dbg_master() (0)
@@ -731,6 +744,13 @@ int del_timer(struct timer_list *timer);

 #define mmiowb() barrier()

+/* String-to-integer conversions; each driver's kos_kernel.c implements them. */
+extern int kstrtol(const char *s, unsigned int base, long *res);
+extern int kstrtoul(const char *s, unsigned int base, unsigned long *res);
+extern int kstrtoint(const char *s, unsigned int base, int *res);
+extern int kstrtou32(const char *s, unsigned int base, u32 *res);
+
+
 #define dev_err(dev, format, arg...)            \
        printk("Error %s " format, __func__ , ## arg)

@@ -740,6 +760,18 @@ int del_timer(struct timer_list *timer);
 #define dev_info(dev, format, arg...)       \
        printk("Info %s " format , __func__, ## arg)

+/*
+ * nouveau routes all of its logging through dev_*() (NV_PRINTK in
+ * nouveau_drv.h picks the level by name), so the two levels the other drivers
+ * never needed have to exist as well.  dev_dbg() keeps its arguments checked
+ * but emits nothing, matching the !CONFIG_DYNAMIC_DEBUG behaviour upstream.
+ */
+#define dev_crit(dev, format, arg...)            \
+        printk("Critical %s " format, __func__ , ## arg)
+
+#define dev_dbg(dev, format, arg...)             \
+        do { if (0) printk(format, ## arg); } while (0)
+
 struct page
 {
    unsigned int addr;
@@ -0,0 +1,833 @@
+/*
+ * A generic kernel FIFO implementation
+ *
+ * Copyright (C) 2013 Stefani Seibold <stefani@seibold.net>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+#ifndef _LINUX_KFIFO_H
+#define _LINUX_KFIFO_H
+
+/*
+ * How to porting drivers to the new generic FIFO API:
+ *
+ * - Modify the declaration of the "struct kfifo *" object into a
+ *   in-place "struct kfifo" object
+ * - Init the in-place object with kfifo_alloc() or kfifo_init()
+ *   Note: The address of the in-place "struct kfifo" object must be
+ *   passed as the first argument to this functions
+ * - Replace the use of __kfifo_put into kfifo_in and __kfifo_get
+ *   into kfifo_out
+ * - Replace the use of kfifo_put into kfifo_in_spinlocked and kfifo_get
+ *   into kfifo_out_spinlocked
+ *   Note: the spinlock pointer formerly passed to kfifo_init/kfifo_alloc
+ *   must be passed now to the kfifo_in_spinlocked and kfifo_out_spinlocked
+ *   as the last parameter
+ * - The formerly __kfifo_* functions are renamed into kfifo_*
+ */
+
+/*
+ * Note about locking : There is no locking required until only * one reader
+ * and one writer is using the fifo and no kfifo_reset() will be * called
+ *  kfifo_reset_out() can be safely used, until it will be only called
+ * in the reader thread.
+ *  For multiple writer and one reader there is only a need to lock the writer.
+ * And vice versa for only one writer and multiple reader there is only a need
+ * to lock the reader.
+ */
+
+#include <linux/kernel.h>
+#include <linux/spinlock.h>
+#include <linux/stddef.h>
+#include <linux/scatterlist.h>
+
+struct __kfifo {
+	unsigned int	in;
+	unsigned int	out;
+	unsigned int	mask;
+	unsigned int	esize;
+	void		*data;
+};
+
+#define __STRUCT_KFIFO_COMMON(datatype, recsize, ptrtype) \
+	union { \
+		struct __kfifo	kfifo; \
+		datatype	*type; \
+		const datatype	*const_type; \
+		char		(*rectype)[recsize]; \
+		ptrtype		*ptr; \
+		ptrtype const	*ptr_const; \
+	}
+
+#define __STRUCT_KFIFO(type, size, recsize, ptrtype) \
+{ \
+	__STRUCT_KFIFO_COMMON(type, recsize, ptrtype); \
+	type		buf[((size < 2) || (size & (size - 1))) ? -1 : size]; \
+}
+
+#define STRUCT_KFIFO(type, size) \
+	struct __STRUCT_KFIFO(type, size, 0, type)
+
+#define __STRUCT_KFIFO_PTR(type, recsize, ptrtype) \
+{ \
+	__STRUCT_KFIFO_COMMON(type, recsize, ptrtype); \
+	type		buf[0]; \
+}
+
+#define STRUCT_KFIFO_PTR(type) \
+	struct __STRUCT_KFIFO_PTR(type, 0, type)
+
+/*
+ * define compatibility "struct kfifo" for dynamic allocated fifos
+ */
+struct kfifo __STRUCT_KFIFO_PTR(unsigned char, 0, void);
+
+#define STRUCT_KFIFO_REC_1(size) \
+	struct __STRUCT_KFIFO(unsigned char, size, 1, void)
+
+#define STRUCT_KFIFO_REC_2(size) \
+	struct __STRUCT_KFIFO(unsigned char, size, 2, void)
+
+/*
+ * define kfifo_rec types
+ */
+struct kfifo_rec_ptr_1 __STRUCT_KFIFO_PTR(unsigned char, 1, void);
+struct kfifo_rec_ptr_2 __STRUCT_KFIFO_PTR(unsigned char, 2, void);
+
+/*
+ * helper macro to distinguish between real in place fifo where the fifo
+ * array is a part of the structure and the fifo type where the array is
+ * outside of the fifo structure.
+ */
+#define	__is_kfifo_ptr(fifo)	(sizeof(*fifo) == sizeof(struct __kfifo))
+
+/**
+ * DECLARE_KFIFO_PTR - macro to declare a fifo pointer object
+ * @fifo: name of the declared fifo
+ * @type: type of the fifo elements
+ */
+#define DECLARE_KFIFO_PTR(fifo, type)	STRUCT_KFIFO_PTR(type) fifo
+
+/**
+ * DECLARE_KFIFO - macro to declare a fifo object
+ * @fifo: name of the declared fifo
+ * @type: type of the fifo elements
+ * @size: the number of elements in the fifo, this must be a power of 2
+ */
+#define DECLARE_KFIFO(fifo, type, size)	STRUCT_KFIFO(type, size) fifo
+
+/**
+ * INIT_KFIFO - Initialize a fifo declared by DECLARE_KFIFO
+ * @fifo: name of the declared fifo datatype
+ */
+#define INIT_KFIFO(fifo) \
+(void)({ \
+	typeof(&(fifo)) __tmp = &(fifo); \
+	struct __kfifo *__kfifo = &__tmp->kfifo; \
+	__kfifo->in = 0; \
+	__kfifo->out = 0; \
+	__kfifo->mask = __is_kfifo_ptr(__tmp) ? 0 : ARRAY_SIZE(__tmp->buf) - 1;\
+	__kfifo->esize = sizeof(*__tmp->buf); \
+	__kfifo->data = __is_kfifo_ptr(__tmp) ?  NULL : __tmp->buf; \
+})
+
+/**
+ * DEFINE_KFIFO - macro to define and initialize a fifo
+ * @fifo: name of the declared fifo datatype
+ * @type: type of the fifo elements
+ * @size: the number of elements in the fifo, this must be a power of 2
+ *
+ * Note: the macro can be used for global and local fifo data type variables.
+ */
+#define DEFINE_KFIFO(fifo, type, size) \
+	DECLARE_KFIFO(fifo, type, size) = \
+	(typeof(fifo)) { \
+		{ \
+			{ \
+			.in	= 0, \
+			.out	= 0, \
+			.mask	= __is_kfifo_ptr(&(fifo)) ? \
+				  0 : \
+				  ARRAY_SIZE((fifo).buf) - 1, \
+			.esize	= sizeof(*(fifo).buf), \
+			.data	= __is_kfifo_ptr(&(fifo)) ? \
+				NULL : \
+				(fifo).buf, \
+			} \
+		} \
+	}
+
+
+static inline unsigned int __must_check
+__kfifo_uint_must_check_helper(unsigned int val)
+{
+	return val;
+}
+
+static inline int __must_check
+__kfifo_int_must_check_helper(int val)
+{
+	return val;
+}
+
+/**
+ * kfifo_initialized - Check if the fifo is initialized
+ * @fifo: address of the fifo to check
+ *
+ * Return %true if fifo is initialized, otherwise %false.
+ * Assumes the fifo was 0 before.
+ */
+#define kfifo_initialized(fifo) ((fifo)->kfifo.mask)
+
+/**
+ * kfifo_esize - returns the size of the element managed by the fifo
+ * @fifo: address of the fifo to be used
+ */
+#define kfifo_esize(fifo)	((fifo)->kfifo.esize)
+
+/**
+ * kfifo_recsize - returns the size of the record length field
+ * @fifo: address of the fifo to be used
+ */
+#define kfifo_recsize(fifo)	(sizeof(*(fifo)->rectype))
+
+/**
+ * kfifo_size - returns the size of the fifo in elements
+ * @fifo: address of the fifo to be used
+ */
+#define kfifo_size(fifo)	((fifo)->kfifo.mask + 1)
+
+/**
+ * kfifo_reset - removes the entire fifo content
+ * @fifo: address of the fifo to be used
+ *
+ * Note: usage of kfifo_reset() is dangerous. It should be only called when the
+ * fifo is exclusived locked or when it is secured that no other thread is
+ * accessing the fifo.
+ */
+#define kfifo_reset(fifo) \
+(void)({ \
+	typeof((fifo) + 1) __tmp = (fifo); \
+	__tmp->kfifo.in = __tmp->kfifo.out = 0; \
+})
+
+/**
+ * kfifo_reset_out - skip fifo content
+ * @fifo: address of the fifo to be used
+ *
+ * Note: The usage of kfifo_reset_out() is safe until it will be only called
+ * from the reader thread and there is only one concurrent reader. Otherwise
+ * it is dangerous and must be handled in the same way as kfifo_reset().
+ */
+#define kfifo_reset_out(fifo)	\
+(void)({ \
+	typeof((fifo) + 1) __tmp = (fifo); \
+	__tmp->kfifo.out = __tmp->kfifo.in; \
+})
+
+/**
+ * kfifo_len - returns the number of used elements in the fifo
+ * @fifo: address of the fifo to be used
+ */
+#define kfifo_len(fifo) \
+({ \
+	typeof((fifo) + 1) __tmpl = (fifo); \
+	__tmpl->kfifo.in - __tmpl->kfifo.out; \
+})
+
+/**
+ * kfifo_is_empty - returns true if the fifo is empty
+ * @fifo: address of the fifo to be used
+ */
+#define	kfifo_is_empty(fifo) \
+({ \
+	typeof((fifo) + 1) __tmpq = (fifo); \
+	__tmpq->kfifo.in == __tmpq->kfifo.out; \
+})
+
+/**
+ * kfifo_is_full - returns true if the fifo is full
+ * @fifo: address of the fifo to be used
+ */
+#define	kfifo_is_full(fifo) \
+({ \
+	typeof((fifo) + 1) __tmpq = (fifo); \
+	kfifo_len(__tmpq) > __tmpq->kfifo.mask; \
+})
+
+/**
+ * kfifo_avail - returns the number of unused elements in the fifo
+ * @fifo: address of the fifo to be used
+ */
+#define	kfifo_avail(fifo) \
+__kfifo_uint_must_check_helper( \
+({ \
+	typeof((fifo) + 1) __tmpq = (fifo); \
+	const size_t __recsize = sizeof(*__tmpq->rectype); \
+	unsigned int __avail = kfifo_size(__tmpq) - kfifo_len(__tmpq); \
+	(__recsize) ? ((__avail <= __recsize) ? 0 : \
+	__kfifo_max_r(__avail - __recsize, __recsize)) : \
+	__avail; \
+}) \
+)
+
+/**
+ * kfifo_skip - skip output data
+ * @fifo: address of the fifo to be used
+ */
+#define	kfifo_skip(fifo) \
+(void)({ \
+	typeof((fifo) + 1) __tmp = (fifo); \
+	const size_t __recsize = sizeof(*__tmp->rectype); \
+	struct __kfifo *__kfifo = &__tmp->kfifo; \
+	if (__recsize) \
+		__kfifo_skip_r(__kfifo, __recsize); \
+	else \
+		__kfifo->out++; \
+})
+
+/**
+ * kfifo_peek_len - gets the size of the next fifo record
+ * @fifo: address of the fifo to be used
+ *
+ * This function returns the size of the next fifo record in number of bytes.
+ */
+#define kfifo_peek_len(fifo) \
+__kfifo_uint_must_check_helper( \
+({ \
+	typeof((fifo) + 1) __tmp = (fifo); \
+	const size_t __recsize = sizeof(*__tmp->rectype); \
+	struct __kfifo *__kfifo = &__tmp->kfifo; \
+	(!__recsize) ? kfifo_len(__tmp) * sizeof(*__tmp->type) : \
+	__kfifo_len_r(__kfifo, __recsize); \
+}) \
+)
+
+/**
+ * kfifo_alloc - dynamically allocates a new fifo buffer
+ * @fifo: pointer to the fifo
+ * @size: the number of elements in the fifo, this must be a power of 2
+ * @gfp_mask: get_free_pages mask, passed to kmalloc()
+ *
+ * This macro dynamically allocates a new fifo buffer.
+ *
+ * The numer of elements will be rounded-up to a power of 2.
+ * The fifo will be release with kfifo_free().
+ * Return 0 if no error, otherwise an error code.
+ */
+#define kfifo_alloc(fifo, size, gfp_mask) \
+__kfifo_int_must_check_helper( \
+({ \
+	typeof((fifo) + 1) __tmp = (fifo); \
+	struct __kfifo *__kfifo = &__tmp->kfifo; \
+	__is_kfifo_ptr(__tmp) ? \
+	__kfifo_alloc(__kfifo, size, sizeof(*__tmp->type), gfp_mask) : \
+	-EINVAL; \
+}) \
+)
+
+/**
+ * kfifo_free - frees the fifo
+ * @fifo: the fifo to be freed
+ */
+#define kfifo_free(fifo) \
+({ \
+	typeof((fifo) + 1) __tmp = (fifo); \
+	struct __kfifo *__kfifo = &__tmp->kfifo; \
+	if (__is_kfifo_ptr(__tmp)) \
+		__kfifo_free(__kfifo); \
+})
+
+/**
+ * kfifo_init - initialize a fifo using a preallocated buffer
+ * @fifo: the fifo to assign the buffer
+ * @buffer: the preallocated buffer to be used
+ * @size: the size of the internal buffer, this have to be a power of 2
+ *
+ * This macro initialize a fifo using a preallocated buffer.
+ *
+ * The numer of elements will be rounded-up to a power of 2.
+ * Return 0 if no error, otherwise an error code.
+ */
+#define kfifo_init(fifo, buffer, size) \
+({ \
+	typeof((fifo) + 1) __tmp = (fifo); \
+	struct __kfifo *__kfifo = &__tmp->kfifo; \
+	__is_kfifo_ptr(__tmp) ? \
+	__kfifo_init(__kfifo, buffer, size, sizeof(*__tmp->type)) : \
+	-EINVAL; \
+})
+
+/**
+ * kfifo_put - put data into the fifo
+ * @fifo: address of the fifo to be used
+ * @val: the data to be added
+ *
+ * This macro copies the given value into the fifo.
+ * It returns 0 if the fifo was full. Otherwise it returns the number
+ * processed elements.
+ *
+ * Note that with only one concurrent reader and one concurrent
+ * writer, you don't need extra locking to use these macro.
+ */
+#define	kfifo_put(fifo, val) \
+({ \
+	typeof((fifo) + 1) __tmp = (fifo); \
+	typeof(*__tmp->const_type) __val = (val); \
+	unsigned int __ret; \
+	size_t __recsize = sizeof(*__tmp->rectype); \
+	struct __kfifo *__kfifo = &__tmp->kfifo; \
+	if (__recsize) \
+		__ret = __kfifo_in_r(__kfifo, &__val, sizeof(__val), \
+			__recsize); \
+	else { \
+		__ret = !kfifo_is_full(__tmp); \
+		if (__ret) { \
+			(__is_kfifo_ptr(__tmp) ? \
+			((typeof(__tmp->type))__kfifo->data) : \
+			(__tmp->buf) \
+			)[__kfifo->in & __tmp->kfifo.mask] = \
+				*(typeof(__tmp->type))&__val; \
+			smp_wmb(); \
+			__kfifo->in++; \
+		} \
+	} \
+	__ret; \
+})
+
+/**
+ * kfifo_get - get data from the fifo
+ * @fifo: address of the fifo to be used
+ * @val: address where to store the data
+ *
+ * This macro reads the data from the fifo.
+ * It returns 0 if the fifo was empty. Otherwise it returns the number
+ * processed elements.
+ *
+ * Note that with only one concurrent reader and one concurrent
+ * writer, you don't need extra locking to use these macro.
+ */
+#define	kfifo_get(fifo, val) \
+__kfifo_uint_must_check_helper( \
+({ \
+	typeof((fifo) + 1) __tmp = (fifo); \
+	typeof(__tmp->ptr) __val = (val); \
+	unsigned int __ret; \
+	const size_t __recsize = sizeof(*__tmp->rectype); \
+	struct __kfifo *__kfifo = &__tmp->kfifo; \
+	if (__recsize) \
+		__ret = __kfifo_out_r(__kfifo, __val, sizeof(*__val), \
+			__recsize); \
+	else { \
+		__ret = !kfifo_is_empty(__tmp); \
+		if (__ret) { \
+			*(typeof(__tmp->type))__val = \
+				(__is_kfifo_ptr(__tmp) ? \
+				((typeof(__tmp->type))__kfifo->data) : \
+				(__tmp->buf) \
+				)[__kfifo->out & __tmp->kfifo.mask]; \
+			smp_wmb(); \
+			__kfifo->out++; \
+		} \
+	} \
+	__ret; \
+}) \
+)
+
+/**
+ * kfifo_peek - get data from the fifo without removing
+ * @fifo: address of the fifo to be used
+ * @val: address where to store the data
+ *
+ * This reads the data from the fifo without removing it from the fifo.
+ * It returns 0 if the fifo was empty. Otherwise it returns the number
+ * processed elements.
+ *
+ * Note that with only one concurrent reader and one concurrent
+ * writer, you don't need extra locking to use these macro.
+ */
+#define	kfifo_peek(fifo, val) \
+__kfifo_uint_must_check_helper( \
+({ \
+	typeof((fifo) + 1) __tmp = (fifo); \
+	typeof(__tmp->ptr) __val = (val); \
+	unsigned int __ret; \
+	const size_t __recsize = sizeof(*__tmp->rectype); \
+	struct __kfifo *__kfifo = &__tmp->kfifo; \
+	if (__recsize) \
+		__ret = __kfifo_out_peek_r(__kfifo, __val, sizeof(*__val), \
+			__recsize); \
+	else { \
+		__ret = !kfifo_is_empty(__tmp); \
+		if (__ret) { \
+			*(typeof(__tmp->type))__val = \
+				(__is_kfifo_ptr(__tmp) ? \
+				((typeof(__tmp->type))__kfifo->data) : \
+				(__tmp->buf) \
+				)[__kfifo->out & __tmp->kfifo.mask]; \
+			smp_wmb(); \
+		} \
+	} \
+	__ret; \
+}) \
+)
+
+/**
+ * kfifo_in - put data into the fifo
+ * @fifo: address of the fifo to be used
+ * @buf: the data to be added
+ * @n: number of elements to be added
+ *
+ * This macro copies the given buffer into the fifo and returns the
+ * number of copied elements.
+ *
+ * Note that with only one concurrent reader and one concurrent
+ * writer, you don't need extra locking to use these macro.
+ */
+#define	kfifo_in(fifo, buf, n) \
+({ \
+	typeof((fifo) + 1) __tmp = (fifo); \
+	typeof(__tmp->ptr_const) __buf = (buf); \
+	unsigned long __n = (n); \
+	const size_t __recsize = sizeof(*__tmp->rectype); \
+	struct __kfifo *__kfifo = &__tmp->kfifo; \
+	(__recsize) ?\
+	__kfifo_in_r(__kfifo, __buf, __n, __recsize) : \
+	__kfifo_in(__kfifo, __buf, __n); \
+})
+
+/**
+ * kfifo_in_spinlocked - put data into the fifo using a spinlock for locking
+ * @fifo: address of the fifo to be used
+ * @buf: the data to be added
+ * @n: number of elements to be added
+ * @lock: pointer to the spinlock to use for locking
+ *
+ * This macro copies the given values buffer into the fifo and returns the
+ * number of copied elements.
+ */
+#define	kfifo_in_spinlocked(fifo, buf, n, lock) \
+({ \
+	unsigned long __flags; \
+	unsigned int __ret; \
+	spin_lock_irqsave(lock, __flags); \
+	__ret = kfifo_in(fifo, buf, n); \
+	spin_unlock_irqrestore(lock, __flags); \
+	__ret; \
+})
+
+/* alias for kfifo_in_spinlocked, will be removed in a future release */
+#define kfifo_in_locked(fifo, buf, n, lock) \
+		kfifo_in_spinlocked(fifo, buf, n, lock)
+
+/**
+ * kfifo_out - get data from the fifo
+ * @fifo: address of the fifo to be used
+ * @buf: pointer to the storage buffer
+ * @n: max. number of elements to get
+ *
+ * This macro get some data from the fifo and return the numbers of elements
+ * copied.
+ *
+ * Note that with only one concurrent reader and one concurrent
+ * writer, you don't need extra locking to use these macro.
+ */
+#define	kfifo_out(fifo, buf, n) \
+__kfifo_uint_must_check_helper( \
+({ \
+	typeof((fifo) + 1) __tmp = (fifo); \
+	typeof(__tmp->ptr) __buf = (buf); \
+	unsigned long __n = (n); \
+	const size_t __recsize = sizeof(*__tmp->rectype); \
+	struct __kfifo *__kfifo = &__tmp->kfifo; \
+	(__recsize) ?\
+	__kfifo_out_r(__kfifo, __buf, __n, __recsize) : \
+	__kfifo_out(__kfifo, __buf, __n); \
+}) \
+)
+
+/**
+ * kfifo_out_spinlocked - get data from the fifo using a spinlock for locking
+ * @fifo: address of the fifo to be used
+ * @buf: pointer to the storage buffer
+ * @n: max. number of elements to get
+ * @lock: pointer to the spinlock to use for locking
+ *
+ * This macro get the data from the fifo and return the numbers of elements
+ * copied.
+ */
+#define	kfifo_out_spinlocked(fifo, buf, n, lock) \
+__kfifo_uint_must_check_helper( \
+({ \
+	unsigned long __flags; \
+	unsigned int __ret; \
+	spin_lock_irqsave(lock, __flags); \
+	__ret = kfifo_out(fifo, buf, n); \
+	spin_unlock_irqrestore(lock, __flags); \
+	__ret; \
+}) \
+)
+
+/* alias for kfifo_out_spinlocked, will be removed in a future release */
+#define kfifo_out_locked(fifo, buf, n, lock) \
+		kfifo_out_spinlocked(fifo, buf, n, lock)
+
+/**
+ * kfifo_from_user - puts some data from user space into the fifo
+ * @fifo: address of the fifo to be used
+ * @from: pointer to the data to be added
+ * @len: the length of the data to be added
+ * @copied: pointer to output variable to store the number of copied bytes
+ *
+ * This macro copies at most @len bytes from the @from into the
+ * fifo, depending of the available space and returns -EFAULT/0.
+ *
+ * Note that with only one concurrent reader and one concurrent
+ * writer, you don't need extra locking to use these macro.
+ */
+#define	kfifo_from_user(fifo, from, len, copied) \
+__kfifo_uint_must_check_helper( \
+({ \
+	typeof((fifo) + 1) __tmp = (fifo); \
+	const void __user *__from = (from); \
+	unsigned int __len = (len); \
+	unsigned int *__copied = (copied); \
+	const size_t __recsize = sizeof(*__tmp->rectype); \
+	struct __kfifo *__kfifo = &__tmp->kfifo; \
+	(__recsize) ? \
+	__kfifo_from_user_r(__kfifo, __from, __len,  __copied, __recsize) : \
+	__kfifo_from_user(__kfifo, __from, __len, __copied); \
+}) \
+)
+
+/**
+ * kfifo_to_user - copies data from the fifo into user space
+ * @fifo: address of the fifo to be used
+ * @to: where the data must be copied
+ * @len: the size of the destination buffer
+ * @copied: pointer to output variable to store the number of copied bytes
+ *
+ * This macro copies at most @len bytes from the fifo into the
+ * @to buffer and returns -EFAULT/0.
+ *
+ * Note that with only one concurrent reader and one concurrent
+ * writer, you don't need extra locking to use these macro.
+ */
+#define	kfifo_to_user(fifo, to, len, copied) \
+__kfifo_uint_must_check_helper( \
+({ \
+	typeof((fifo) + 1) __tmp = (fifo); \
+	void __user *__to = (to); \
+	unsigned int __len = (len); \
+	unsigned int *__copied = (copied); \
+	const size_t __recsize = sizeof(*__tmp->rectype); \
+	struct __kfifo *__kfifo = &__tmp->kfifo; \
+	(__recsize) ? \
+	__kfifo_to_user_r(__kfifo, __to, __len, __copied, __recsize) : \
+	__kfifo_to_user(__kfifo, __to, __len, __copied); \
+}) \
+)
+
+/**
+ * kfifo_dma_in_prepare - setup a scatterlist for DMA input
+ * @fifo: address of the fifo to be used
+ * @sgl: pointer to the scatterlist array
+ * @nents: number of entries in the scatterlist array
+ * @len: number of elements to transfer
+ *
+ * This macro fills a scatterlist for DMA input.
+ * It returns the number entries in the scatterlist array.
+ *
+ * Note that with only one concurrent reader and one concurrent
+ * writer, you don't need extra locking to use these macros.
+ */
+#define	kfifo_dma_in_prepare(fifo, sgl, nents, len) \
+({ \
+	typeof((fifo) + 1) __tmp = (fifo); \
+	struct scatterlist *__sgl = (sgl); \
+	int __nents = (nents); \
+	unsigned int __len = (len); \
+	const size_t __recsize = sizeof(*__tmp->rectype); \
+	struct __kfifo *__kfifo = &__tmp->kfifo; \
+	(__recsize) ? \
+	__kfifo_dma_in_prepare_r(__kfifo, __sgl, __nents, __len, __recsize) : \
+	__kfifo_dma_in_prepare(__kfifo, __sgl, __nents, __len); \
+})
+
+/**
+ * kfifo_dma_in_finish - finish a DMA IN operation
+ * @fifo: address of the fifo to be used
+ * @len: number of bytes to received
+ *
+ * This macro finish a DMA IN operation. The in counter will be updated by
+ * the len parameter. No error checking will be done.
+ *
+ * Note that with only one concurrent reader and one concurrent
+ * writer, you don't need extra locking to use these macros.
+ */
+#define kfifo_dma_in_finish(fifo, len) \
+(void)({ \
+	typeof((fifo) + 1) __tmp = (fifo); \
+	unsigned int __len = (len); \
+	const size_t __recsize = sizeof(*__tmp->rectype); \
+	struct __kfifo *__kfifo = &__tmp->kfifo; \
+	if (__recsize) \
+		__kfifo_dma_in_finish_r(__kfifo, __len, __recsize); \
+	else \
+		__kfifo->in += __len / sizeof(*__tmp->type); \
+})
+
+/**
+ * kfifo_dma_out_prepare - setup a scatterlist for DMA output
+ * @fifo: address of the fifo to be used
+ * @sgl: pointer to the scatterlist array
+ * @nents: number of entries in the scatterlist array
+ * @len: number of elements to transfer
+ *
+ * This macro fills a scatterlist for DMA output which at most @len bytes
+ * to transfer.
+ * It returns the number entries in the scatterlist array.
+ * A zero means there is no space available and the scatterlist is not filled.
+ *
+ * Note that with only one concurrent reader and one concurrent
+ * writer, you don't need extra locking to use these macros.
+ */
+#define	kfifo_dma_out_prepare(fifo, sgl, nents, len) \
+({ \
+	typeof((fifo) + 1) __tmp = (fifo);  \
+	struct scatterlist *__sgl = (sgl); \
+	int __nents = (nents); \
+	unsigned int __len = (len); \
+	const size_t __recsize = sizeof(*__tmp->rectype); \
+	struct __kfifo *__kfifo = &__tmp->kfifo; \
+	(__recsize) ? \
+	__kfifo_dma_out_prepare_r(__kfifo, __sgl, __nents, __len, __recsize) : \
+	__kfifo_dma_out_prepare(__kfifo, __sgl, __nents, __len); \
+})
+
+/**
+ * kfifo_dma_out_finish - finish a DMA OUT operation
+ * @fifo: address of the fifo to be used
+ * @len: number of bytes transferred
+ *
+ * This macro finish a DMA OUT operation. The out counter will be updated by
+ * the len parameter. No error checking will be done.
+ *
+ * Note that with only one concurrent reader and one concurrent
+ * writer, you don't need extra locking to use these macros.
+ */
+#define kfifo_dma_out_finish(fifo, len) \
+(void)({ \
+	typeof((fifo) + 1) __tmp = (fifo); \
+	unsigned int __len = (len); \
+	const size_t __recsize = sizeof(*__tmp->rectype); \
+	struct __kfifo *__kfifo = &__tmp->kfifo; \
+	if (__recsize) \
+		__kfifo_dma_out_finish_r(__kfifo, __recsize); \
+	else \
+		__kfifo->out += __len / sizeof(*__tmp->type); \
+})
+
+/**
+ * kfifo_out_peek - gets some data from the fifo
+ * @fifo: address of the fifo to be used
+ * @buf: pointer to the storage buffer
+ * @n: max. number of elements to get
+ *
+ * This macro get the data from the fifo and return the numbers of elements
+ * copied. The data is not removed from the fifo.
+ *
+ * Note that with only one concurrent reader and one concurrent
+ * writer, you don't need extra locking to use these macro.
+ */
+#define	kfifo_out_peek(fifo, buf, n) \
+__kfifo_uint_must_check_helper( \
+({ \
+	typeof((fifo) + 1) __tmp = (fifo); \
+	typeof(__tmp->ptr) __buf = (buf); \
+	unsigned long __n = (n); \
+	const size_t __recsize = sizeof(*__tmp->rectype); \
+	struct __kfifo *__kfifo = &__tmp->kfifo; \
+	(__recsize) ? \
+	__kfifo_out_peek_r(__kfifo, __buf, __n, __recsize) : \
+	__kfifo_out_peek(__kfifo, __buf, __n); \
+}) \
+)
+
+extern int __kfifo_alloc(struct __kfifo *fifo, unsigned int size,
+	size_t esize, gfp_t gfp_mask);
+
+extern void __kfifo_free(struct __kfifo *fifo);
+
+extern int __kfifo_init(struct __kfifo *fifo, void *buffer,
+	unsigned int size, size_t esize);
+
+extern unsigned int __kfifo_in(struct __kfifo *fifo,
+	const void *buf, unsigned int len);
+
+extern unsigned int __kfifo_out(struct __kfifo *fifo,
+	void *buf, unsigned int len);
+
+extern int __kfifo_from_user(struct __kfifo *fifo,
+	const void __user *from, unsigned long len, unsigned int *copied);
+
+extern int __kfifo_to_user(struct __kfifo *fifo,
+	void __user *to, unsigned long len, unsigned int *copied);
+
+extern unsigned int __kfifo_dma_in_prepare(struct __kfifo *fifo,
+	struct scatterlist *sgl, int nents, unsigned int len);
+
+extern unsigned int __kfifo_dma_out_prepare(struct __kfifo *fifo,
+	struct scatterlist *sgl, int nents, unsigned int len);
+
+extern unsigned int __kfifo_out_peek(struct __kfifo *fifo,
+	void *buf, unsigned int len);
+
+extern unsigned int __kfifo_in_r(struct __kfifo *fifo,
+	const void *buf, unsigned int len, size_t recsize);
+
+extern unsigned int __kfifo_out_r(struct __kfifo *fifo,
+	void *buf, unsigned int len, size_t recsize);
+
+extern int __kfifo_from_user_r(struct __kfifo *fifo,
+	const void __user *from, unsigned long len, unsigned int *copied,
+	size_t recsize);
+
+extern int __kfifo_to_user_r(struct __kfifo *fifo, void __user *to,
+	unsigned long len, unsigned int *copied, size_t recsize);
+
+extern unsigned int __kfifo_dma_in_prepare_r(struct __kfifo *fifo,
+	struct scatterlist *sgl, int nents, unsigned int len, size_t recsize);
+
+extern void __kfifo_dma_in_finish_r(struct __kfifo *fifo,
+	unsigned int len, size_t recsize);
+
+extern unsigned int __kfifo_dma_out_prepare_r(struct __kfifo *fifo,
+	struct scatterlist *sgl, int nents, unsigned int len, size_t recsize);
+
+extern void __kfifo_dma_out_finish_r(struct __kfifo *fifo, size_t recsize);
+
+extern unsigned int __kfifo_len_r(struct __kfifo *fifo, size_t recsize);
+
+extern void __kfifo_skip_r(struct __kfifo *fifo, size_t recsize);
+
+extern unsigned int __kfifo_out_peek_r(struct __kfifo *fifo,
+	void *buf, unsigned int len, size_t recsize);
+
+extern unsigned int __kfifo_max_r(unsigned int len, size_t recsize);
+
+#endif
@@ -0,0 +1,57 @@
+#ifndef _LINUX_KTHREAD_H
+#define _LINUX_KTHREAD_H
+/*
+ * Minimal kthread emulation for KolibriOS.
+ *
+ * The GPU scheduler (drivers/video/drm/amdgpu/scheduler) is the only user in
+ * the DRM tree.  KolibriOS kernel threads are created with CreateKernelThread(),
+ * which takes no argument, so kthread_run() stashes the payload in a small
+ * pid-indexed table and the trampoline picks it up.  Park/stop are cooperative
+ * flags polled by the thread body, matching how the scheduler uses them.
+ */
+
+#include <linux/types.h>
+#include <linux/sched.h>
+#include <linux/err.h>
+#include <linux/rwsem.h>
+
+/*
+ * Placeholder address space.  Drivers reach it as current->mm on their userptr
+ * paths only, which KolibriOS never enters (no ioctl surface for user code).
+ */
+struct mm_struct {
+	struct rw_semaphore mmap_sem;
+};
+
+struct task_struct {
+	int	(*threadfn)(void *data);
+	void	 *data;
+	int	  pid;
+	volatile int should_stop;
+	volatile int should_park;
+	volatile int parked;
+	char	  comm[16];
+	struct mm_struct *mm;
+};
+
+struct task_struct *kthread_create_kos(int (*threadfn)(void *data),
+				       void *data, const char *name);
+int  kthread_stop(struct task_struct *k);
+bool kthread_should_stop(void);
+bool kthread_should_park(void);
+void kthread_parkme(void);
+int  kthread_park(struct task_struct *k);
+void kthread_unpark(struct task_struct *k);
+struct task_struct *kthread_current(void);
+
+#define kthread_run(threadfn, data, namefmt, ...) \
+	kthread_create_kos((threadfn), (data), (namefmt))
+
+#define kthread_create(threadfn, data, namefmt, ...) \
+	kthread_create_kos((threadfn), (data), (namefmt))
+
+static inline void wake_up_process(struct task_struct *k) { }
+static inline void get_task_struct(struct task_struct *k) { }
+static inline void put_task_struct(struct task_struct *k) { }
+
+#endif /* _LINUX_KTHREAD_H */
@@ -0,0 +1,24 @@
+#ifndef _LINUX_MFD_CORE_H
+#define _LINUX_MFD_CORE_H
+/*
+ * No multi-function-device bus on KolibriOS.  amdgpu_acp.h embeds an
+ * mfd_cell pointer in struct amdgpu_acp; the ACP block itself is not built.
+ */
+#include <linux/types.h>
+struct device;
+struct resource;
+
+struct mfd_cell {
+	const char	*name;
+	int		 id;
+	void		*platform_data;
+	size_t		 pdata_size;
+	int		 num_resources;
+	const struct resource *resources;
+};
+
+static inline int mfd_add_hotplug_devices(struct device *parent,
+					  const struct mfd_cell *cells, int n)
+	{ return -ENODEV; }
+static inline void mfd_remove_devices(struct device *parent) { }
+#endif
@@ -8,6 +8,12 @@
 #define nth_page(page,n) ((void*)(((page_to_phys(page)>>12)+(n))<<12))

 #define __page_to_pfn(page) (page_to_phys(page)>>12)
+/*
+ * A struct page * here is just the physical address (see page_to_phys() in
+ * <linux/kernel.h>), so the reverse direction is the same shift back.
+ */
+#define __pfn_to_page(pfn)  ((struct page *)((dma_addr_t)(pfn) << 12))
+#define pfn_to_page(pfn)    __pfn_to_page(pfn)

 /* to align the pointer to the (next) page boundary */
 #define PAGE_ALIGN(addr) ALIGN(addr, PAGE_SIZE)
@@ -26,4 +26,14 @@

 struct module {};

+/*
+ * Nothing is a module here - everything is linked into the one image - so the
+ * reference count can never drop and a request for another module can never be
+ * satisfied.  Implemented in the driver's kos_* glue.
+ */
+extern int request_module(const char *name, ...);
+extern int try_module_get(struct module *module);
+extern void module_put(struct module *module);
+
+
 #endif /* _LINUX_MODULE_H */
@@ -77,6 +77,15 @@ void __attribute__ ((fastcall)) __attribute__ ((dllimport))
 void __attribute__ ((fastcall)) __attribute__ ((dllimport))
     mutex_unlock(struct mutex*)__asm__("MutexUnlock");

+/*
+ * mutex_init() is the DDK's MutexInit(); these two are the spellings upstream
+ * code reaches for when it wants a lockdep class, which this port does not
+ * have.  Both end up in the same place.
+ */
+extern void __mutex_init(struct mutex *lock, const char *name,
+			 struct lock_class_key *key);
+extern void mutex_lock_nested(struct mutex *lock, unsigned int subclass);
+
 static inline int mutex_lock_interruptible(struct mutex *lock)
 {
    mutex_lock(lock);
@@ -0,0 +1,10 @@
+#ifndef _LINUX_OF_DEVICE_H
+#define _LINUX_OF_DEVICE_H
+/* No device tree on x86; pulled in unconditionally by nvif/os.h. */
+struct device;
+struct of_device_id;
+
+static inline const struct of_device_id *
+of_match_device(const struct of_device_id *m, const struct device *dev)
+{ return NULL; }
+#endif
@@ -0,0 +1,8 @@
+#ifndef _LINUX_PAGEMAP_H
+#define _LINUX_PAGEMAP_H
+/* Only the shift/size helpers are used by the TTM/GEM paths on this port. */
+#include <linux/mm.h>
+#define PAGE_CACHE_SHIFT	PAGE_SHIFT
+#define PAGE_CACHE_SIZE		PAGE_SIZE
+#define PAGE_CACHE_MASK		PAGE_MASK
+#endif
@@ -275,6 +275,13 @@ struct pci_dev {
 	struct pci_bus	*bus;		/* bus this device is on */
 	struct pci_bus	*subordinate;	/* bus this device bridges to */

+	/*
+	 * Always NULL on this port: there is no driver model to bind through.
+	 * nouveau_drm.c reads it to decide whether the HDMI audio function is
+	 * claimed before powering the GPU down, and takes the safe branch.
+	 */
+	struct pci_driver *driver;
+
 	void		*sysdata;	/* hook for sys-specific extension */
 //    struct proc_dir_entry *procent; /* device entry in /proc/bus/pci */
 	struct pci_slot	*slot;		/* Physical slot this device is in */
@@ -0,0 +1,7 @@
+#ifndef _LINUX_PLATFORM_DEVICE_H
+#define _LINUX_PLATFORM_DEVICE_H
+/* No platform bus; amdgpu_drv.h only needs the type to exist. */
+#include <linux/device.h>
+struct platform_device { struct device dev; const char *name; int id; };
+struct platform_driver;
+#endif
@@ -0,0 +1,12 @@
+#ifndef _LINUX_POWER_SUPPLY_H
+#define _LINUX_POWER_SUPPLY_H
+/*
+ * No battery subsystem on KolibriOS.  power_supply_is_system_supplied() is
+ * already provided by <syscall.h>; only the enum labels are missing.
+ */
+enum {
+	POWER_SUPPLY_TYPE_UNKNOWN = 0,
+	POWER_SUPPLY_TYPE_BATTERY,
+	POWER_SUPPLY_TYPE_MAINS,
+};
+#endif
@@ -0,0 +1,22 @@
+#ifndef _LINUX_REBOOT_H
+#define _LINUX_REBOOT_H
+/*
+ * No reboot notifier chain on this port.  nvif/os.h includes this header for
+ * every nvkm translation unit; nothing in the built set registers a notifier.
+ */
+#include <linux/notifier.h>
+
+#define SYS_RESTART	0x0001
+#define SYS_HALT	0x0002
+#define SYS_POWER_OFF	0x0003
+
+static inline int register_reboot_notifier(struct notifier_block *nb) { return 0; }
+static inline int unregister_reboot_notifier(struct notifier_block *nb) { return 0; }
+
+/*
+ * nvkm/subdev/therm/temp.c asks for this when the GPU passes its shutdown
+ * threshold.  There is no orderly shutdown to request on KolibriOS; the
+ * driver's implementation logs and returns.
+ */
+extern int orderly_poweroff(bool force);
+#endif
@@ -0,0 +1,18 @@
+#ifndef _LINUX_REGULATOR_CONSUMER_H
+#define _LINUX_REGULATOR_CONSUMER_H
+/* Tegra-only; see linux/clk.h for why this exists at all. */
+#include <linux/errno.h>
+#include <linux/err.h>
+
+struct regulator;
+struct device;
+
+static inline struct regulator *regulator_get(struct device *dev, const char *id)
+{ return ERR_PTR(-ENOENT); }
+static inline void regulator_put(struct regulator *r) { }
+static inline int regulator_enable(struct regulator *r) { return -ENOSYS; }
+static inline int regulator_disable(struct regulator *r) { return -ENOSYS; }
+static inline int regulator_get_voltage(struct regulator *r) { return -ENODEV; }
+static inline int regulator_set_voltage(struct regulator *r, int min_uV, int max_uV)
+{ return -ENODEV; }
+#endif
@@ -0,0 +1,15 @@
+#ifndef _LINUX_RESET_H
+#define _LINUX_RESET_H
+/* Tegra-only; see linux/clk.h for why this exists at all. */
+#include <linux/errno.h>
+#include <linux/err.h>
+
+struct reset_control;
+struct device;
+
+static inline struct reset_control *reset_control_get(struct device *dev, const char *id)
+{ return ERR_PTR(-ENOENT); }
+static inline void reset_control_put(struct reset_control *rstc) { }
+static inline int reset_control_assert(struct reset_control *rstc) { return -ENOSYS; }
+static inline int reset_control_deassert(struct reset_control *rstc) { return -ENOSYS; }
+#endif
@@ -49,4 +49,14 @@
 #define schedule_timeout(x)  delay(x)
 #define MAX_SCHEDULE_TIMEOUT    LONG_MAX

+/*
+ * No processes and no signals behind a driver thread: signal_pending() is
+ * always false, so interruptible waits only ever end on their timeout, and
+ * every task carries the singleton name set in kos_stubs.c.
+ */
+struct task_struct;
+extern int signal_pending(struct task_struct *p);
+extern void __set_current_state(int state);
+extern char *get_task_comm(char *buf, struct task_struct *tsk);
+
 #endif
@@ -0,0 +1,19 @@
+#ifndef _LINUX_SCREEN_INFO_H
+#define _LINUX_SCREEN_INFO_H
+/*
+ * nouveau_fbcon.c only uses this to decide whether it owns the boot console.
+ * KolibriOS has no boot console to hand over, so the record stays empty.
+ */
+#include <linux/types.h>
+
+struct screen_info {
+	__u8  orig_video_isVGA;
+	__u16 lfb_width;
+	__u16 lfb_height;
+	__u16 lfb_depth;
+	__u32 lfb_base;
+	__u32 lfb_size;
+};
+
+extern struct screen_info screen_info;
+#endif
@@ -0,0 +1,5 @@
+#ifndef _LINUX_SWIOTLB_H
+#define _LINUX_SWIOTLB_H
+/* No bounce buffers on this port; amdgpu_ttm.c only queries swiotlb_nr_tbl(). */
+static inline unsigned long swiotlb_nr_tbl(void) { return 0; }
+#endif
@@ -0,0 +1,35 @@
+#ifndef _LINUX_TRACEPOINT_H
+#define _LINUX_TRACEPOINT_H
+/* Tracepoints compile away: amdgpu_trace.h expands to empty trace_*() calls. */
+/*
+ * Each event still has to yield a callable trace_<name>(), because the driver
+ * code calls it unconditionally - upstream generates one per event.  Here they
+ * expand to empty inlines, so the calls disappear at -O2 but the argument
+ * expressions are still type-checked.
+ */
+#define TP_PROTO(args...)	args
+#define TP_ARGS(args...)	args
+#define TP_STRUCT__entry(args...)
+#define TP_fast_assign(args...)
+#define TP_printk(fmt, args...)
+#define TP_CONDITION(args...)
+
+#define DECLARE_EVENT_CLASS(name, proto, args, tstruct, assign, print)
+
+#define DEFINE_EVENT(tmpl, name, proto, args)				\
+	static inline void trace_##name(proto) { }			\
+	static inline bool trace_##name##_enabled(void) { return false; }
+
+#define TRACE_EVENT(name, proto, args, tstruct, assign, print)		\
+	static inline void trace_##name(proto) { }			\
+	static inline bool trace_##name##_enabled(void) { return false; }
+
+#define TRACE_EVENT_CONDITION(name, proto, args, cond, tstruct, assign, print) \
+	static inline void trace_##name(proto) { }			\
+	static inline bool trace_##name##_enabled(void) { return false; }
+
+#define DECLARE_TRACE(name, proto, args)				\
+	static inline void trace_##name(proto) { }
+#define EXPORT_TRACEPOINT_SYMBOL_GPL(name)
+#define EXPORT_TRACEPOINT_SYMBOL(name)
+#endif
@@ -0,0 +1,5 @@
+#ifndef _LINUX_TTY_H
+#define _LINUX_TTY_H
+/* No tty layer; nouveau_fbcon.c includes it for console_lock() neighbours. */
+#include <linux/console.h>
+#endif
@@ -188,6 +188,7 @@ static inline enum vga_switcheroo_handler_flags_t vga_switcheroo_handler_flags(v
 static inline int vga_switcheroo_lock_ddc(struct pci_dev *pdev) { return -ENODEV; }
 static inline int vga_switcheroo_unlock_ddc(struct pci_dev *pdev) { return -ENODEV; }
 static inline int vga_switcheroo_process_delayed_switch(void) { return 0; }
+static inline bool vga_switcheroo_client_probe_defer(struct pci_dev *pdev) { return false; }
 static inline enum vga_switcheroo_state vga_switcheroo_get_client_state(struct pci_dev *dev) { return VGA_SWITCHEROO_ON; }

 static inline void vga_switcheroo_set_dynamic_switch(struct pci_dev *pdev, enum vga_switcheroo_state dynamic) {}
@@ -30,6 +30,12 @@ extern void *vmalloc(unsigned long size);
 extern void *vzalloc(unsigned long size);
 extern void vfree(const void *addr);

+/*
+ * kmalloc() and vmalloc() come from the same allocator on this port, so one
+ * free serves both - which is what kvfree() means upstream too.
+ */
+extern void kvfree(const void *addr);
+
 extern void *vmap(struct page **pages, unsigned int count,
 			unsigned long flags, pgprot_t prot);
 extern void vunmap(const void *addr);
@@ -326,6 +326,30 @@ int autoremove_wake_function(wait_queue_t *wait, unsigned mode, int sync, void *

 #define DEFINE_WAIT(name) DEFINE_WAIT_FUNC(name, autoremove_wake_function)

+/*
+ * The "_locked" variants are entered with wq.lock already held and must give
+ * it up while waiting.  That rules out the event-based path above, which takes
+ * the lock itself, so these poll instead - the same trade the rest of this
+ * header already makes.
+ *
+ * Because nothing ever blocks on an event here, wake_up_all_locked() has
+ * nothing to signal: the waiter re-tests the condition on its next tick.
+ */
+#define wait_event_interruptible_locked(wq, condition)			\
+({									\
+	while (!(condition)) {						\
+		spin_unlock(&(wq).lock);				\
+		delay(1);						\
+		spin_lock(&(wq).lock);					\
+	}								\
+	0;								\
+})
+
+#define wait_event_locked(wq, condition) \
+	wait_event_interruptible_locked(wq, condition)
+
+#define wake_up_locked(q)	do { } while (0)
+#define wake_up_all_locked(q)	do { } while (0)

 #endif

@@ -268,6 +268,9 @@ static inline bool mod_delayed_work(struct workqueue_struct *wq,
        (_work)->work.func = _func;             \
    } while (0)

+/* Defined in each driver's kos_kernel.c. */
+extern bool flush_work(struct work_struct *work);
+
 static inline bool schedule_work(struct work_struct *work)
 {
    return queue_work(system_wq, work);
@@ -0,0 +1,5 @@
+#ifndef __SOC_TEGRA_FUSE_H
+#define __SOC_TEGRA_FUSE_H
+/* Tegra-only; nvif/os.h includes it unconditionally. */
+static inline int tegra_sku_info_dummy(void) { return 0; }
+#endif
@@ -0,0 +1,5 @@
+#ifndef __SOC_TEGRA_PMC_H
+#define __SOC_TEGRA_PMC_H
+/* Tegra-only; nvif/os.h includes it unconditionally. */
+static inline int tegra_pmc_dummy(void) { return 0; }
+#endif
@@ -0,0 +1,5 @@
+#ifndef _TRACE_DEFINE_TRACE_H
+#define _TRACE_DEFINE_TRACE_H
+/* Tracepoints are compiled out - see linux/tracepoint.h. */
+#undef TRACE_HEADER_MULTI_READ
+#endif
@@ -0,0 +1,6 @@
+#ifndef _TRACE_EVENTS_FENCE_H
+#define _TRACE_EVENTS_FENCE_H
+/* Tracepoints are compiled out; nouveau_fence.c is the only includer. */
+struct fence;
+static inline void trace_fence_emit(struct fence *fence) { }
+#endif
@@ -68,7 +68,14 @@
 	 ((nr)   << _IOC_NRSHIFT) | \
 	 ((size) << _IOC_SIZESHIFT))

-#ifndef __KERNEL__
+#ifdef __KERNEL__
+/* provoke compile error for invalid uses of size argument */
+extern unsigned int __invalid_size_argument_for_IOC;
+#define _IOC_TYPECHECK(t)						\
+	((sizeof(t) == sizeof(t[1]) &&					\
+	  sizeof(t) < (1 << _IOC_SIZEBITS)) ?				\
+	  sizeof(t) : __invalid_size_argument_for_IOC)
+#else
 #define _IOC_TYPECHECK(t) (sizeof(t))
 #endif

@@ -0,0 +1,662 @@
+/* amdgpu_drm.h -- Public header for the amdgpu driver -*- linux-c -*-
+ *
+ * Copyright 2000 Precision Insight, Inc., Cedar Park, Texas.
+ * Copyright 2000 VA Linux Systems, Inc., Fremont, California.
+ * Copyright 2002 Tungsten Graphics, Inc., Cedar Park, Texas.
+ * Copyright 2014 Advanced Micro Devices, Inc.
+ *
+ * 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 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 COPYRIGHT HOLDER(S) OR AUTHOR(S) 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:
+ *    Kevin E. Martin <martin@valinux.com>
+ *    Gareth Hughes <gareth@valinux.com>
+ *    Keith Whitwell <keith@tungstengraphics.com>
+ */
+
+#ifndef __AMDGPU_DRM_H__
+#define __AMDGPU_DRM_H__
+
+#include "drm.h"
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+#define DRM_AMDGPU_GEM_CREATE		0x00
+#define DRM_AMDGPU_GEM_MMAP		0x01
+#define DRM_AMDGPU_CTX			0x02
+#define DRM_AMDGPU_BO_LIST		0x03
+#define DRM_AMDGPU_CS			0x04
+#define DRM_AMDGPU_INFO			0x05
+#define DRM_AMDGPU_GEM_METADATA		0x06
+#define DRM_AMDGPU_GEM_WAIT_IDLE	0x07
+#define DRM_AMDGPU_GEM_VA		0x08
+#define DRM_AMDGPU_WAIT_CS		0x09
+#define DRM_AMDGPU_GEM_OP		0x10
+#define DRM_AMDGPU_GEM_USERPTR		0x11
+
+#define DRM_IOCTL_AMDGPU_GEM_CREATE	DRM_IOWR(DRM_COMMAND_BASE + DRM_AMDGPU_GEM_CREATE, union drm_amdgpu_gem_create)
+#define DRM_IOCTL_AMDGPU_GEM_MMAP	DRM_IOWR(DRM_COMMAND_BASE + DRM_AMDGPU_GEM_MMAP, union drm_amdgpu_gem_mmap)
+#define DRM_IOCTL_AMDGPU_CTX		DRM_IOWR(DRM_COMMAND_BASE + DRM_AMDGPU_CTX, union drm_amdgpu_ctx)
+#define DRM_IOCTL_AMDGPU_BO_LIST	DRM_IOWR(DRM_COMMAND_BASE + DRM_AMDGPU_BO_LIST, union drm_amdgpu_bo_list)
+#define DRM_IOCTL_AMDGPU_CS		DRM_IOWR(DRM_COMMAND_BASE + DRM_AMDGPU_CS, union drm_amdgpu_cs)
+#define DRM_IOCTL_AMDGPU_INFO		DRM_IOW(DRM_COMMAND_BASE + DRM_AMDGPU_INFO, struct drm_amdgpu_info)
+#define DRM_IOCTL_AMDGPU_GEM_METADATA	DRM_IOWR(DRM_COMMAND_BASE + DRM_AMDGPU_GEM_METADATA, struct drm_amdgpu_gem_metadata)
+#define DRM_IOCTL_AMDGPU_GEM_WAIT_IDLE	DRM_IOWR(DRM_COMMAND_BASE + DRM_AMDGPU_GEM_WAIT_IDLE, union drm_amdgpu_gem_wait_idle)
+#define DRM_IOCTL_AMDGPU_GEM_VA		DRM_IOW(DRM_COMMAND_BASE + DRM_AMDGPU_GEM_VA, struct drm_amdgpu_gem_va)
+#define DRM_IOCTL_AMDGPU_WAIT_CS	DRM_IOWR(DRM_COMMAND_BASE + DRM_AMDGPU_WAIT_CS, union drm_amdgpu_wait_cs)
+#define DRM_IOCTL_AMDGPU_GEM_OP		DRM_IOWR(DRM_COMMAND_BASE + DRM_AMDGPU_GEM_OP, struct drm_amdgpu_gem_op)
+#define DRM_IOCTL_AMDGPU_GEM_USERPTR	DRM_IOWR(DRM_COMMAND_BASE + DRM_AMDGPU_GEM_USERPTR, struct drm_amdgpu_gem_userptr)
+
+#define AMDGPU_GEM_DOMAIN_CPU		0x1
+#define AMDGPU_GEM_DOMAIN_GTT		0x2
+#define AMDGPU_GEM_DOMAIN_VRAM		0x4
+#define AMDGPU_GEM_DOMAIN_GDS		0x8
+#define AMDGPU_GEM_DOMAIN_GWS		0x10
+#define AMDGPU_GEM_DOMAIN_OA		0x20
+
+/* Flag that CPU access will be required for the case of VRAM domain */
+#define AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED	(1 << 0)
+/* Flag that CPU access will not work, this VRAM domain is invisible */
+#define AMDGPU_GEM_CREATE_NO_CPU_ACCESS		(1 << 1)
+/* Flag that USWC attributes should be used for GTT */
+#define AMDGPU_GEM_CREATE_CPU_GTT_USWC		(1 << 2)
+/* Flag that the memory should be in VRAM and cleared */
+#define AMDGPU_GEM_CREATE_VRAM_CLEARED		(1 << 3)
+/* Flag that create shadow bo(GTT) while allocating vram bo */
+#define AMDGPU_GEM_CREATE_SHADOW		(1 << 4)
+
+struct drm_amdgpu_gem_create_in  {
+	/** the requested memory size */
+	__u64 bo_size;
+	/** physical start_addr alignment in bytes for some HW requirements */
+	__u64 alignment;
+	/** the requested memory domains */
+	__u64 domains;
+	/** allocation flags */
+	__u64 domain_flags;
+};
+
+struct drm_amdgpu_gem_create_out  {
+	/** returned GEM object handle */
+	__u32 handle;
+	__u32 _pad;
+};
+
+union drm_amdgpu_gem_create {
+	struct drm_amdgpu_gem_create_in		in;
+	struct drm_amdgpu_gem_create_out	out;
+};
+
+/** Opcode to create new residency list.  */
+#define AMDGPU_BO_LIST_OP_CREATE	0
+/** Opcode to destroy previously created residency list */
+#define AMDGPU_BO_LIST_OP_DESTROY	1
+/** Opcode to update resource information in the list */
+#define AMDGPU_BO_LIST_OP_UPDATE	2
+
+struct drm_amdgpu_bo_list_in {
+	/** Type of operation */
+	__u32 operation;
+	/** Handle of list or 0 if we want to create one */
+	__u32 list_handle;
+	/** Number of BOs in list  */
+	__u32 bo_number;
+	/** Size of each element describing BO */
+	__u32 bo_info_size;
+	/** Pointer to array describing BOs */
+	__u64 bo_info_ptr;
+};
+
+struct drm_amdgpu_bo_list_entry {
+	/** Handle of BO */
+	__u32 bo_handle;
+	/** New (if specified) BO priority to be used during migration */
+	__u32 bo_priority;
+};
+
+struct drm_amdgpu_bo_list_out {
+	/** Handle of resource list  */
+	__u32 list_handle;
+	__u32 _pad;
+};
+
+union drm_amdgpu_bo_list {
+	struct drm_amdgpu_bo_list_in in;
+	struct drm_amdgpu_bo_list_out out;
+};
+
+/* context related */
+#define AMDGPU_CTX_OP_ALLOC_CTX	1
+#define AMDGPU_CTX_OP_FREE_CTX	2
+#define AMDGPU_CTX_OP_QUERY_STATE	3
+
+/* GPU reset status */
+#define AMDGPU_CTX_NO_RESET		0
+/* this the context caused it */
+#define AMDGPU_CTX_GUILTY_RESET		1
+/* some other context caused it */
+#define AMDGPU_CTX_INNOCENT_RESET	2
+/* unknown cause */
+#define AMDGPU_CTX_UNKNOWN_RESET	3
+
+struct drm_amdgpu_ctx_in {
+	/** AMDGPU_CTX_OP_* */
+	__u32	op;
+	/** For future use, no flags defined so far */
+	__u32	flags;
+	__u32	ctx_id;
+	__u32	_pad;
+};
+
+union drm_amdgpu_ctx_out {
+		struct {
+			__u32	ctx_id;
+			__u32	_pad;
+		} alloc;
+
+		struct {
+			/** For future use, no flags defined so far */
+			__u64	flags;
+			/** Number of resets caused by this context so far. */
+			__u32	hangs;
+			/** Reset status since the last call of the ioctl. */
+			__u32	reset_status;
+		} state;
+};
+
+union drm_amdgpu_ctx {
+	struct drm_amdgpu_ctx_in in;
+	union drm_amdgpu_ctx_out out;
+};
+
+/*
+ * This is not a reliable API and you should expect it to fail for any
+ * number of reasons and have fallback path that do not use userptr to
+ * perform any operation.
+ */
+#define AMDGPU_GEM_USERPTR_READONLY	(1 << 0)
+#define AMDGPU_GEM_USERPTR_ANONONLY	(1 << 1)
+#define AMDGPU_GEM_USERPTR_VALIDATE	(1 << 2)
+#define AMDGPU_GEM_USERPTR_REGISTER	(1 << 3)
+
+struct drm_amdgpu_gem_userptr {
+	__u64		addr;
+	__u64		size;
+	/* AMDGPU_GEM_USERPTR_* */
+	__u32		flags;
+	/* Resulting GEM handle */
+	__u32		handle;
+};
+
+/* same meaning as the GB_TILE_MODE and GL_MACRO_TILE_MODE fields */
+#define AMDGPU_TILING_ARRAY_MODE_SHIFT			0
+#define AMDGPU_TILING_ARRAY_MODE_MASK			0xf
+#define AMDGPU_TILING_PIPE_CONFIG_SHIFT			4
+#define AMDGPU_TILING_PIPE_CONFIG_MASK			0x1f
+#define AMDGPU_TILING_TILE_SPLIT_SHIFT			9
+#define AMDGPU_TILING_TILE_SPLIT_MASK			0x7
+#define AMDGPU_TILING_MICRO_TILE_MODE_SHIFT		12
+#define AMDGPU_TILING_MICRO_TILE_MODE_MASK		0x7
+#define AMDGPU_TILING_BANK_WIDTH_SHIFT			15
+#define AMDGPU_TILING_BANK_WIDTH_MASK			0x3
+#define AMDGPU_TILING_BANK_HEIGHT_SHIFT			17
+#define AMDGPU_TILING_BANK_HEIGHT_MASK			0x3
+#define AMDGPU_TILING_MACRO_TILE_ASPECT_SHIFT		19
+#define AMDGPU_TILING_MACRO_TILE_ASPECT_MASK		0x3
+#define AMDGPU_TILING_NUM_BANKS_SHIFT			21
+#define AMDGPU_TILING_NUM_BANKS_MASK			0x3
+
+#define AMDGPU_TILING_SET(field, value) \
+	(((value) & AMDGPU_TILING_##field##_MASK) << AMDGPU_TILING_##field##_SHIFT)
+#define AMDGPU_TILING_GET(value, field) \
+	(((value) >> AMDGPU_TILING_##field##_SHIFT) & AMDGPU_TILING_##field##_MASK)
+
+#define AMDGPU_GEM_METADATA_OP_SET_METADATA                  1
+#define AMDGPU_GEM_METADATA_OP_GET_METADATA                  2
+
+/** The same structure is shared for input/output */
+struct drm_amdgpu_gem_metadata {
+	/** GEM Object handle */
+	__u32	handle;
+	/** Do we want get or set metadata */
+	__u32	op;
+	struct {
+		/** For future use, no flags defined so far */
+		__u64	flags;
+		/** family specific tiling info */
+		__u64	tiling_info;
+		__u32	data_size_bytes;
+		__u32	data[64];
+	} data;
+};
+
+struct drm_amdgpu_gem_mmap_in {
+	/** the GEM object handle */
+	__u32 handle;
+	__u32 _pad;
+};
+
+struct drm_amdgpu_gem_mmap_out {
+	/** mmap offset from the vma offset manager */
+	__u64 addr_ptr;
+};
+
+union drm_amdgpu_gem_mmap {
+	struct drm_amdgpu_gem_mmap_in   in;
+	struct drm_amdgpu_gem_mmap_out out;
+};
+
+struct drm_amdgpu_gem_wait_idle_in {
+	/** GEM object handle */
+	__u32 handle;
+	/** For future use, no flags defined so far */
+	__u32 flags;
+	/** Absolute timeout to wait */
+	__u64 timeout;
+};
+
+struct drm_amdgpu_gem_wait_idle_out {
+	/** BO status:  0 - BO is idle, 1 - BO is busy */
+	__u32 status;
+	/** Returned current memory domain */
+	__u32 domain;
+};
+
+union drm_amdgpu_gem_wait_idle {
+	struct drm_amdgpu_gem_wait_idle_in  in;
+	struct drm_amdgpu_gem_wait_idle_out out;
+};
+
+struct drm_amdgpu_wait_cs_in {
+	/** Command submission handle */
+	__u64 handle;
+	/** Absolute timeout to wait */
+	__u64 timeout;
+	__u32 ip_type;
+	__u32 ip_instance;
+	__u32 ring;
+	__u32 ctx_id;
+};
+
+struct drm_amdgpu_wait_cs_out {
+	/** CS status:  0 - CS completed, 1 - CS still busy */
+	__u64 status;
+};
+
+union drm_amdgpu_wait_cs {
+	struct drm_amdgpu_wait_cs_in in;
+	struct drm_amdgpu_wait_cs_out out;
+};
+
+#define AMDGPU_GEM_OP_GET_GEM_CREATE_INFO	0
+#define AMDGPU_GEM_OP_SET_PLACEMENT		1
+
+/* Sets or returns a value associated with a buffer. */
+struct drm_amdgpu_gem_op {
+	/** GEM object handle */
+	__u32	handle;
+	/** AMDGPU_GEM_OP_* */
+	__u32	op;
+	/** Input or return value */
+	__u64	value;
+};
+
+#define AMDGPU_VA_OP_MAP			1
+#define AMDGPU_VA_OP_UNMAP			2
+
+/* Delay the page table update till the next CS */
+#define AMDGPU_VM_DELAY_UPDATE		(1 << 0)
+
+/* Mapping flags */
+/* readable mapping */
+#define AMDGPU_VM_PAGE_READABLE		(1 << 1)
+/* writable mapping */
+#define AMDGPU_VM_PAGE_WRITEABLE	(1 << 2)
+/* executable mapping, new for VI */
+#define AMDGPU_VM_PAGE_EXECUTABLE	(1 << 3)
+
+struct drm_amdgpu_gem_va {
+	/** GEM object handle */
+	__u32 handle;
+	__u32 _pad;
+	/** AMDGPU_VA_OP_* */
+	__u32 operation;
+	/** AMDGPU_VM_PAGE_* */
+	__u32 flags;
+	/** va address to assign . Must be correctly aligned.*/
+	__u64 va_address;
+	/** Specify offset inside of BO to assign. Must be correctly aligned.*/
+	__u64 offset_in_bo;
+	/** Specify mapping size. Must be correctly aligned. */
+	__u64 map_size;
+};
+
+#define AMDGPU_HW_IP_GFX          0
+#define AMDGPU_HW_IP_COMPUTE      1
+#define AMDGPU_HW_IP_DMA          2
+#define AMDGPU_HW_IP_UVD          3
+#define AMDGPU_HW_IP_VCE          4
+#define AMDGPU_HW_IP_NUM          5
+
+#define AMDGPU_HW_IP_INSTANCE_MAX_COUNT 1
+
+#define AMDGPU_CHUNK_ID_IB		0x01
+#define AMDGPU_CHUNK_ID_FENCE		0x02
+#define AMDGPU_CHUNK_ID_DEPENDENCIES	0x03
+
+struct drm_amdgpu_cs_chunk {
+	__u32		chunk_id;
+	__u32		length_dw;
+	__u64		chunk_data;
+};
+
+struct drm_amdgpu_cs_in {
+	/** Rendering context id */
+	__u32		ctx_id;
+	/**  Handle of resource list associated with CS */
+	__u32		bo_list_handle;
+	__u32		num_chunks;
+	__u32		_pad;
+	/** this points to __u64 * which point to cs chunks */
+	__u64		chunks;
+};
+
+struct drm_amdgpu_cs_out {
+	__u64 handle;
+};
+
+union drm_amdgpu_cs {
+	struct drm_amdgpu_cs_in in;
+	struct drm_amdgpu_cs_out out;
+};
+
+/* Specify flags to be used for IB */
+
+/* This IB should be submitted to CE */
+#define AMDGPU_IB_FLAG_CE	(1<<0)
+
+/* CE Preamble */
+#define AMDGPU_IB_FLAG_PREAMBLE (1<<1)
+
+struct drm_amdgpu_cs_chunk_ib {
+	__u32 _pad;
+	/** AMDGPU_IB_FLAG_* */
+	__u32 flags;
+	/** Virtual address to begin IB execution */
+	__u64 va_start;
+	/** Size of submission */
+	__u32 ib_bytes;
+	/** HW IP to submit to */
+	__u32 ip_type;
+	/** HW IP index of the same type to submit to  */
+	__u32 ip_instance;
+	/** Ring index to submit to */
+	__u32 ring;
+};
+
+struct drm_amdgpu_cs_chunk_dep {
+	__u32 ip_type;
+	__u32 ip_instance;
+	__u32 ring;
+	__u32 ctx_id;
+	__u64 handle;
+};
+
+struct drm_amdgpu_cs_chunk_fence {
+	__u32 handle;
+	__u32 offset;
+};
+
+struct drm_amdgpu_cs_chunk_data {
+	union {
+		struct drm_amdgpu_cs_chunk_ib		ib_data;
+		struct drm_amdgpu_cs_chunk_fence	fence_data;
+	};
+};
+
+/**
+ *  Query h/w info: Flag that this is integrated (a.h.a. fusion) GPU
+ *
+ */
+#define AMDGPU_IDS_FLAGS_FUSION         0x1
+
+/* indicate if acceleration can be working */
+#define AMDGPU_INFO_ACCEL_WORKING		0x00
+/* get the crtc_id from the mode object id? */
+#define AMDGPU_INFO_CRTC_FROM_ID		0x01
+/* query hw IP info */
+#define AMDGPU_INFO_HW_IP_INFO			0x02
+/* query hw IP instance count for the specified type */
+#define AMDGPU_INFO_HW_IP_COUNT			0x03
+/* timestamp for GL_ARB_timer_query */
+#define AMDGPU_INFO_TIMESTAMP			0x05
+/* Query the firmware version */
+#define AMDGPU_INFO_FW_VERSION			0x0e
+	/* Subquery id: Query VCE firmware version */
+	#define AMDGPU_INFO_FW_VCE		0x1
+	/* Subquery id: Query UVD firmware version */
+	#define AMDGPU_INFO_FW_UVD		0x2
+	/* Subquery id: Query GMC firmware version */
+	#define AMDGPU_INFO_FW_GMC		0x03
+	/* Subquery id: Query GFX ME firmware version */
+	#define AMDGPU_INFO_FW_GFX_ME		0x04
+	/* Subquery id: Query GFX PFP firmware version */
+	#define AMDGPU_INFO_FW_GFX_PFP		0x05
+	/* Subquery id: Query GFX CE firmware version */
+	#define AMDGPU_INFO_FW_GFX_CE		0x06
+	/* Subquery id: Query GFX RLC firmware version */
+	#define AMDGPU_INFO_FW_GFX_RLC		0x07
+	/* Subquery id: Query GFX MEC firmware version */
+	#define AMDGPU_INFO_FW_GFX_MEC		0x08
+	/* Subquery id: Query SMC firmware version */
+	#define AMDGPU_INFO_FW_SMC		0x0a
+	/* Subquery id: Query SDMA firmware version */
+	#define AMDGPU_INFO_FW_SDMA		0x0b
+/* number of bytes moved for TTM migration */
+#define AMDGPU_INFO_NUM_BYTES_MOVED		0x0f
+/* the used VRAM size */
+#define AMDGPU_INFO_VRAM_USAGE			0x10
+/* the used GTT size */
+#define AMDGPU_INFO_GTT_USAGE			0x11
+/* Information about GDS, etc. resource configuration */
+#define AMDGPU_INFO_GDS_CONFIG			0x13
+/* Query information about VRAM and GTT domains */
+#define AMDGPU_INFO_VRAM_GTT			0x14
+/* Query information about register in MMR address space*/
+#define AMDGPU_INFO_READ_MMR_REG		0x15
+/* Query information about device: rev id, family, etc. */
+#define AMDGPU_INFO_DEV_INFO			0x16
+/* visible vram usage */
+#define AMDGPU_INFO_VIS_VRAM_USAGE		0x17
+/* number of TTM buffer evictions */
+#define AMDGPU_INFO_NUM_EVICTIONS		0x18
+
+#define AMDGPU_INFO_MMR_SE_INDEX_SHIFT	0
+#define AMDGPU_INFO_MMR_SE_INDEX_MASK	0xff
+#define AMDGPU_INFO_MMR_SH_INDEX_SHIFT	8
+#define AMDGPU_INFO_MMR_SH_INDEX_MASK	0xff
+
+struct drm_amdgpu_query_fw {
+	/** AMDGPU_INFO_FW_* */
+	__u32 fw_type;
+	/**
+	 * Index of the IP if there are more IPs of
+	 * the same type.
+	 */
+	__u32 ip_instance;
+	/**
+	 * Index of the engine. Whether this is used depends
+	 * on the firmware type. (e.g. MEC, SDMA)
+	 */
+	__u32 index;
+	__u32 _pad;
+};
+
+/* Input structure for the INFO ioctl */
+struct drm_amdgpu_info {
+	/* Where the return value will be stored */
+	__u64 return_pointer;
+	/* The size of the return value. Just like "size" in "snprintf",
+	 * it limits how many bytes the kernel can write. */
+	__u32 return_size;
+	/* The query request id. */
+	__u32 query;
+
+	union {
+		struct {
+			__u32 id;
+			__u32 _pad;
+		} mode_crtc;
+
+		struct {
+			/** AMDGPU_HW_IP_* */
+			__u32 type;
+			/**
+			 * Index of the IP if there are more IPs of the same
+			 * type. Ignored by AMDGPU_INFO_HW_IP_COUNT.
+			 */
+			__u32 ip_instance;
+		} query_hw_ip;
+
+		struct {
+			__u32 dword_offset;
+			/** number of registers to read */
+			__u32 count;
+			__u32 instance;
+			/** For future use, no flags defined so far */
+			__u32 flags;
+		} read_mmr_reg;
+
+		struct drm_amdgpu_query_fw query_fw;
+	};
+};
+
+struct drm_amdgpu_info_gds {
+	/** GDS GFX partition size */
+	__u32 gds_gfx_partition_size;
+	/** GDS compute partition size */
+	__u32 compute_partition_size;
+	/** total GDS memory size */
+	__u32 gds_total_size;
+	/** GWS size per GFX partition */
+	__u32 gws_per_gfx_partition;
+	/** GSW size per compute partition */
+	__u32 gws_per_compute_partition;
+	/** OA size per GFX partition */
+	__u32 oa_per_gfx_partition;
+	/** OA size per compute partition */
+	__u32 oa_per_compute_partition;
+	__u32 _pad;
+};
+
+struct drm_amdgpu_info_vram_gtt {
+	__u64 vram_size;
+	__u64 vram_cpu_accessible_size;
+	__u64 gtt_size;
+};
+
+struct drm_amdgpu_info_firmware {
+	__u32 ver;
+	__u32 feature;
+};
+
+#define AMDGPU_VRAM_TYPE_UNKNOWN 0
+#define AMDGPU_VRAM_TYPE_GDDR1 1
+#define AMDGPU_VRAM_TYPE_DDR2  2
+#define AMDGPU_VRAM_TYPE_GDDR3 3
+#define AMDGPU_VRAM_TYPE_GDDR4 4
+#define AMDGPU_VRAM_TYPE_GDDR5 5
+#define AMDGPU_VRAM_TYPE_HBM   6
+#define AMDGPU_VRAM_TYPE_DDR3  7
+
+struct drm_amdgpu_info_device {
+	/** PCI Device ID */
+	__u32 device_id;
+	/** Internal chip revision: A0, A1, etc.) */
+	__u32 chip_rev;
+	__u32 external_rev;
+	/** Revision id in PCI Config space */
+	__u32 pci_rev;
+	__u32 family;
+	__u32 num_shader_engines;
+	__u32 num_shader_arrays_per_engine;
+	/* in KHz */
+	__u32 gpu_counter_freq;
+	__u64 max_engine_clock;
+	__u64 max_memory_clock;
+	/* cu information */
+	__u32 cu_active_number;
+	__u32 cu_ao_mask;
+	__u32 cu_bitmap[4][4];
+	/** Render backend pipe mask. One render backend is CB+DB. */
+	__u32 enabled_rb_pipes_mask;
+	__u32 num_rb_pipes;
+	__u32 num_hw_gfx_contexts;
+	__u32 _pad;
+	__u64 ids_flags;
+	/** Starting virtual address for UMDs. */
+	__u64 virtual_address_offset;
+	/** The maximum virtual address */
+	__u64 virtual_address_max;
+	/** Required alignment of virtual addresses. */
+	__u32 virtual_address_alignment;
+	/** Page table entry - fragment size */
+	__u32 pte_fragment_size;
+	__u32 gart_page_size;
+	/** constant engine ram size*/
+	__u32 ce_ram_size;
+	/** video memory type info*/
+	__u32 vram_type;
+	/** video memory bit width*/
+	__u32 vram_bit_width;
+	/* vce harvesting instance */
+	__u32 vce_harvest_config;
+};
+
+struct drm_amdgpu_info_hw_ip {
+	/** Version of h/w IP */
+	__u32  hw_ip_version_major;
+	__u32  hw_ip_version_minor;
+	/** Capabilities */
+	__u64  capabilities_flags;
+	/** command buffer address start alignment*/
+	__u32  ib_start_alignment;
+	/** command buffer size alignment*/
+	__u32  ib_size_alignment;
+	/** Bitmask of available rings. Bit 0 means ring 0, etc. */
+	__u32  available_rings;
+	__u32  _pad;
+};
+
+/*
+ * Supported GPU families
+ */
+#define AMDGPU_FAMILY_UNKNOWN			0
+#define AMDGPU_FAMILY_SI			110 /* Hainan, Oland, Verde, Pitcairn, Tahiti */
+#define AMDGPU_FAMILY_CI			120 /* Bonaire, Hawaii */
+#define AMDGPU_FAMILY_KV			125 /* Kaveri, Kabini, Mullins */
+#define AMDGPU_FAMILY_VI			130 /* Iceland, Tonga */
+#define AMDGPU_FAMILY_CZ			135 /* Carrizo, Stoney */
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif
@@ -0,0 +1,152 @@
+/*
+ * Copyright 2005 Stephane Marchesin.
+ * All Rights Reserved.
+ *
+ * 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
+ * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS 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.
+ */
+
+#ifndef __NOUVEAU_DRM_H__
+#define __NOUVEAU_DRM_H__
+
+#define DRM_NOUVEAU_EVENT_NVIF                                       0x80000000
+
+#include "drm.h"
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+#define NOUVEAU_GEM_DOMAIN_CPU       (1 << 0)
+#define NOUVEAU_GEM_DOMAIN_VRAM      (1 << 1)
+#define NOUVEAU_GEM_DOMAIN_GART      (1 << 2)
+#define NOUVEAU_GEM_DOMAIN_MAPPABLE  (1 << 3)
+#define NOUVEAU_GEM_DOMAIN_COHERENT  (1 << 4)
+
+#define NOUVEAU_GEM_TILE_COMP        0x00030000 /* nv50-only */
+#define NOUVEAU_GEM_TILE_LAYOUT_MASK 0x0000ff00
+#define NOUVEAU_GEM_TILE_16BPP       0x00000001
+#define NOUVEAU_GEM_TILE_32BPP       0x00000002
+#define NOUVEAU_GEM_TILE_ZETA        0x00000004
+#define NOUVEAU_GEM_TILE_NONCONTIG   0x00000008
+
+struct drm_nouveau_gem_info {
+	__u32 handle;
+	__u32 domain;
+	__u64 size;
+	__u64 offset;
+	__u64 map_handle;
+	__u32 tile_mode;
+	__u32 tile_flags;
+};
+
+struct drm_nouveau_gem_new {
+	struct drm_nouveau_gem_info info;
+	__u32 channel_hint;
+	__u32 align;
+};
+
+#define NOUVEAU_GEM_MAX_BUFFERS 1024
+struct drm_nouveau_gem_pushbuf_bo_presumed {
+	__u32 valid;
+	__u32 domain;
+	__u64 offset;
+};
+
+struct drm_nouveau_gem_pushbuf_bo {
+	__u64 user_priv;
+	__u32 handle;
+	__u32 read_domains;
+	__u32 write_domains;
+	__u32 valid_domains;
+	struct drm_nouveau_gem_pushbuf_bo_presumed presumed;
+};
+
+#define NOUVEAU_GEM_RELOC_LOW  (1 << 0)
+#define NOUVEAU_GEM_RELOC_HIGH (1 << 1)
+#define NOUVEAU_GEM_RELOC_OR   (1 << 2)
+#define NOUVEAU_GEM_MAX_RELOCS 1024
+struct drm_nouveau_gem_pushbuf_reloc {
+	__u32 reloc_bo_index;
+	__u32 reloc_bo_offset;
+	__u32 bo_index;
+	__u32 flags;
+	__u32 data;
+	__u32 vor;
+	__u32 tor;
+};
+
+#define NOUVEAU_GEM_MAX_PUSH 512
+struct drm_nouveau_gem_pushbuf_push {
+	__u32 bo_index;
+	__u32 pad;
+	__u64 offset;
+	__u64 length;
+};
+
+struct drm_nouveau_gem_pushbuf {
+	__u32 channel;
+	__u32 nr_buffers;
+	__u64 buffers;
+	__u32 nr_relocs;
+	__u32 nr_push;
+	__u64 relocs;
+	__u64 push;
+	__u32 suffix0;
+	__u32 suffix1;
+	__u64 vram_available;
+	__u64 gart_available;
+};
+
+#define NOUVEAU_GEM_CPU_PREP_NOWAIT                                  0x00000001
+#define NOUVEAU_GEM_CPU_PREP_WRITE                                   0x00000004
+struct drm_nouveau_gem_cpu_prep {
+	__u32 handle;
+	__u32 flags;
+};
+
+struct drm_nouveau_gem_cpu_fini {
+	__u32 handle;
+};
+
+#define DRM_NOUVEAU_GETPARAM           0x00 /* deprecated */
+#define DRM_NOUVEAU_SETPARAM           0x01 /* deprecated */
+#define DRM_NOUVEAU_CHANNEL_ALLOC      0x02 /* deprecated */
+#define DRM_NOUVEAU_CHANNEL_FREE       0x03 /* deprecated */
+#define DRM_NOUVEAU_GROBJ_ALLOC        0x04 /* deprecated */
+#define DRM_NOUVEAU_NOTIFIEROBJ_ALLOC  0x05 /* deprecated */
+#define DRM_NOUVEAU_GPUOBJ_FREE        0x06 /* deprecated */
+#define DRM_NOUVEAU_NVIF               0x07
+#define DRM_NOUVEAU_GEM_NEW            0x40
+#define DRM_NOUVEAU_GEM_PUSHBUF        0x41
+#define DRM_NOUVEAU_GEM_CPU_PREP       0x42
+#define DRM_NOUVEAU_GEM_CPU_FINI       0x43
+#define DRM_NOUVEAU_GEM_INFO           0x44
+
+#define DRM_IOCTL_NOUVEAU_GEM_NEW            DRM_IOWR(DRM_COMMAND_BASE + DRM_NOUVEAU_GEM_NEW, struct drm_nouveau_gem_new)
+#define DRM_IOCTL_NOUVEAU_GEM_PUSHBUF        DRM_IOWR(DRM_COMMAND_BASE + DRM_NOUVEAU_GEM_PUSHBUF, struct drm_nouveau_gem_pushbuf)
+#define DRM_IOCTL_NOUVEAU_GEM_CPU_PREP       DRM_IOW (DRM_COMMAND_BASE + DRM_NOUVEAU_GEM_CPU_PREP, struct drm_nouveau_gem_cpu_prep)
+#define DRM_IOCTL_NOUVEAU_GEM_CPU_FINI       DRM_IOW (DRM_COMMAND_BASE + DRM_NOUVEAU_GEM_CPU_FINI, struct drm_nouveau_gem_cpu_fini)
+#define DRM_IOCTL_NOUVEAU_GEM_INFO           DRM_IOWR(DRM_COMMAND_BASE + DRM_NOUVEAU_GEM_INFO, struct drm_nouveau_gem_info)
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif /* __NOUVEAU_DRM_H__ */
@@ -1754,8 +1754,14 @@ proc disk_read_write stdcall uses ebx esi edi, \
        mov     eax, [numsectors]
        mov     eax, [eax]
 ; 2. The transfer length for SCSI_{READ,WRITE}10 commands can not be greater
-; than 0xFFFF, so split the request to slices with <= 0xFFFF sectors.
-max_sectors_at_time = 0xFFFF
+; than 0xFFFF sectors, but that is not the practical limit: the field size is
+; the only thing the standard bounds, while real sticks hang their firmware on
+; multi-megabyte single commands. The kernel disk cache asks for as much as
+; CACHE_MAX_ALLOC_SIZE (4 MB) in one call, i.e. 8192 sectors, and that is
+; exactly where such sticks stop answering and re-enumerate. Linux caps
+; usb-storage at 240 sectors (120 KB) for the same reason; do the same and
+; split larger requests into slices.
+max_sectors_at_time = 240
 .split:
        push    eax     ; .length_rest
        cmp     eax, max_sectors_at_time
@@ -0,0 +1,188 @@
+/*
+ * Copyright (C) 2009 Francisco Jerez.
+ * All Rights Reserved.
+ *
+ * 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 COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS 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.
+ *
+ */
+
+#include <linux/module.h>
+
+#include <drm/drm_encoder_slave.h>
+
+/**
+ * drm_i2c_encoder_init - Initialize an I2C slave encoder
+ * @dev:	DRM device.
+ * @encoder:    Encoder to be attached to the I2C device. You aren't
+ *		required to have called drm_encoder_init() before.
+ * @adap:	I2C adapter that will be used to communicate with
+ *		the device.
+ * @info:	Information that will be used to create the I2C device.
+ *		Required fields are @addr and @type.
+ *
+ * Create an I2C device on the specified bus (the module containing its
+ * driver is transparently loaded) and attach it to the specified
+ * &drm_encoder_slave. The @slave_funcs field will be initialized with
+ * the hooks provided by the slave driver.
+ *
+ * If @info->platform_data is non-NULL it will be used as the initial
+ * slave config.
+ *
+ * Returns 0 on success or a negative errno on failure, in particular,
+ * -ENODEV is returned when no matching driver is found.
+ */
+int drm_i2c_encoder_init(struct drm_device *dev,
+			 struct drm_encoder_slave *encoder,
+			 struct i2c_adapter *adap,
+			 const struct i2c_board_info *info)
+{
+	struct module *module = NULL;
+	struct i2c_client *client;
+	struct drm_i2c_encoder_driver *encoder_drv;
+	int err = 0;
+
+	request_module("%s%s", I2C_MODULE_PREFIX, info->type);
+
+	client = i2c_new_device(adap, info);
+	if (!client) {
+		err = -ENOMEM;
+		goto fail;
+	}
+
+	if (!client->dev.driver) {
+		err = -ENODEV;
+		goto fail_unregister;
+	}
+
+	module = client->dev.driver->owner;
+	if (!try_module_get(module)) {
+		err = -ENODEV;
+		goto fail_unregister;
+	}
+
+	encoder->bus_priv = client;
+
+	encoder_drv = to_drm_i2c_encoder_driver(to_i2c_driver(client->dev.driver));
+
+	err = encoder_drv->encoder_init(client, dev, encoder);
+	if (err)
+		goto fail_module_put;
+
+	if (info->platform_data)
+		encoder->slave_funcs->set_config(&encoder->base,
+						 info->platform_data);
+
+	return 0;
+
+fail_module_put:
+	module_put(module);
+fail_unregister:
+	i2c_unregister_device(client);
+fail:
+	return err;
+}
+EXPORT_SYMBOL(drm_i2c_encoder_init);
+
+/**
+ * drm_i2c_encoder_destroy - Unregister the I2C device backing an encoder
+ * @drm_encoder:	Encoder to be unregistered.
+ *
+ * This should be called from the @destroy method of an I2C slave
+ * encoder driver once I2C access is no longer needed.
+ */
+void drm_i2c_encoder_destroy(struct drm_encoder *drm_encoder)
+{
+	struct drm_encoder_slave *encoder = to_encoder_slave(drm_encoder);
+	struct i2c_client *client = drm_i2c_encoder_get_client(drm_encoder);
+	struct module *module = client->dev.driver->owner;
+
+	i2c_unregister_device(client);
+	encoder->bus_priv = NULL;
+
+	module_put(module);
+}
+EXPORT_SYMBOL(drm_i2c_encoder_destroy);
+
+/*
+ * Wrapper fxns which can be plugged in to drm_encoder_helper_funcs:
+ */
+
+static inline const struct drm_encoder_slave_funcs *
+get_slave_funcs(struct drm_encoder *enc)
+{
+	return to_encoder_slave(enc)->slave_funcs;
+}
+
+void drm_i2c_encoder_dpms(struct drm_encoder *encoder, int mode)
+{
+	get_slave_funcs(encoder)->dpms(encoder, mode);
+}
+EXPORT_SYMBOL(drm_i2c_encoder_dpms);
+
+bool drm_i2c_encoder_mode_fixup(struct drm_encoder *encoder,
+		const struct drm_display_mode *mode,
+		struct drm_display_mode *adjusted_mode)
+{
+	if (!get_slave_funcs(encoder)->mode_fixup)
+		return true;
+
+	return get_slave_funcs(encoder)->mode_fixup(encoder, mode, adjusted_mode);
+}
+EXPORT_SYMBOL(drm_i2c_encoder_mode_fixup);
+
+void drm_i2c_encoder_prepare(struct drm_encoder *encoder)
+{
+	drm_i2c_encoder_dpms(encoder, DRM_MODE_DPMS_OFF);
+}
+EXPORT_SYMBOL(drm_i2c_encoder_prepare);
+
+void drm_i2c_encoder_commit(struct drm_encoder *encoder)
+{
+	drm_i2c_encoder_dpms(encoder, DRM_MODE_DPMS_ON);
+}
+EXPORT_SYMBOL(drm_i2c_encoder_commit);
+
+void drm_i2c_encoder_mode_set(struct drm_encoder *encoder,
+		struct drm_display_mode *mode,
+		struct drm_display_mode *adjusted_mode)
+{
+	get_slave_funcs(encoder)->mode_set(encoder, mode, adjusted_mode);
+}
+EXPORT_SYMBOL(drm_i2c_encoder_mode_set);
+
+enum drm_connector_status drm_i2c_encoder_detect(struct drm_encoder *encoder,
+	    struct drm_connector *connector)
+{
+	return get_slave_funcs(encoder)->detect(encoder, connector);
+}
+EXPORT_SYMBOL(drm_i2c_encoder_detect);
+
+void drm_i2c_encoder_save(struct drm_encoder *encoder)
+{
+	get_slave_funcs(encoder)->save(encoder);
+}
+EXPORT_SYMBOL(drm_i2c_encoder_save);
+
+void drm_i2c_encoder_restore(struct drm_encoder *encoder)
+{
+	get_slave_funcs(encoder)->restore(encoder);
+}
+EXPORT_SYMBOL(drm_i2c_encoder_restore);
@@ -2405,11 +2405,12 @@ fat_Write:
 ; hd_extend_file can return three error codes: FAT table error, device error or disk full.
 ; First two cases are fatal errors, in third case we may write some data
        cmp     al, ERROR_DISK_FULL
-        jnz     @f
+        jnz     .noWrite
 ; correct number of bytes to write
        mov     ecx, [edi+28]
        cmp     ecx, ebx
        ja      .length_ok
+.noWrite:
        push    0
 .ret:
        pop     eax eax eax ecx ecx
@@ -48,6 +48,10 @@ dtext:
        add     esp, 28
        ret

+.nomem:
+        add     esp, 40
+        ret
+
 .redirect:
        mov     ebp, [edi]
        add     edi, 8
@@ -81,6 +85,8 @@ dtext:
        mov     [esp+32], eax
        imul    ebp, eax
        stdcall kernel_alloc, ebp
+        test    eax, eax
+        jz      .nomem
        mov     ecx, ebp
        shr     ecx, 2
        mov     [esp+36], eax
@@ -118,7 +118,7 @@ SS_MORETOCOME           = 0x4000
 SS_BLOCKED              = 0x8000


-SOCKET_BUFFER_SIZE      = 4096*8        ; must be 4096*(power of 2) where 'power of 2' is at least 8
+SOCKET_BUFFER_SIZE      = 4096*32       ; must be 4096*(power of 2) where 'power of 2' is at least 8
 MAX_backlog             = 20            ; maximum backlog for stream sockets

 ; Error Codes
@@ -181,6 +181,7 @@ con_cls
 con_get_cursor_pos
 con_set_cursor_pos
 ;____TIME____
+clock
 mktime
 time
 localtime
@@ -5,7 +5,7 @@ void shell_cls()
    __shell_init();
    if (__shell_is_init == __SHELL_INIT_OK)
    {
-        *__shell_shm = SHELL_CLS;
+        __shell_shm->cmd = SHELL_CLS;
        __SHELL_WAIT();
    }
 }
@@ -5,7 +5,7 @@ void shell_exit()
 {
    if (__shell_is_init == __SHELL_INIT_OK)
    {
-        *__shell_shm = SHELL_EXIT;
+        __shell_shm->cmd = SHELL_EXIT;
        __SHELL_WAIT();
        _ksys_shm_close(__shell_shm_name);
    }
@@ -8,9 +8,9 @@ unsigned shell_get_pid()
    __shell_init();
    if (__shell_is_init == __SHELL_INIT_OK)
    {
-        *__shell_shm = SHELL_PID;
+        __shell_shm->cmd = SHELL_PID;
        __SHELL_WAIT();
-        memcpy(&pid, __shell_shm + 1, sizeof(unsigned));
+        memcpy(&pid, __shell_shm->data, sizeof(unsigned));
    }

    return pid;
@@ -6,10 +6,10 @@ char shell_getc()

    if (__shell_is_init == __SHELL_INIT_OK)
    {
-        *__shell_shm = SHELL_GETC;
+        __shell_shm->cmd = SHELL_GETC;
        __SHELL_WAIT();

-        return *(__shell_shm + 1);
+        return __shell_shm->data[0];
    }
    else
    {
@@ -7,9 +7,9 @@ void shell_gets(char *str, int n)

    if (__shell_is_init == __SHELL_INIT_OK)
    {
-        *__shell_shm = SHELL_GETS;
+        __shell_shm->cmd = SHELL_GETS;
        __SHELL_WAIT();

-        strncpy(str, __shell_shm + 1, n);
+        strncpy(str, __shell_shm->data, n);
    }
 }
@@ -6,7 +6,7 @@

 char app_name[13];
 char __shell_shm_name[32];
-char *__shell_shm = NULL;
+struct shell_shm_buffer *__shell_shm = NULL;
 enum __SHELL_INIT_STATE __shell_is_init = __SHELL_NOT_LOADED;

 int __shell_shm_init()
@@ -17,12 +17,12 @@ int __shell_shm_init()

    _ksys_thread_info(&proc_info, -1);
    PID = proc_info.pid;
-    strncpy(app_name, (&proc_info)->name, 12);
+    strncpy(app_name, proc_info.name, sizeof(app_name) - 1);

    itoa(PID, __shell_shm_name);
    strcat(__shell_shm_name, "-SHELL");

-    return _ksys_shm_open(__shell_shm_name, KSYS_SHM_OPEN_ALWAYS | KSYS_SHM_WRITE, SHELL_SHM_MAX, &__shell_shm);
+    return _ksys_shm_open(__shell_shm_name, KSYS_SHM_OPEN_ALWAYS | KSYS_SHM_WRITE, sizeof(*__shell_shm), (char **)&__shell_shm);
 }

 void __shell_init()
@@ -7,12 +7,12 @@

 int shell_ping()
 {
-    *__shell_shm = SHELL_PING;
+    __shell_shm->cmd = SHELL_PING;

    _ksys_thread_yield(); // hope shell is fast enough

    size_t i = 0;
-    while (*__shell_shm != SHELL_OK)
+    while (__shell_shm->cmd != SHELL_OK)
    {
        if (i > (SHELL_PING_TIMEOUT / SHELL_PING_MIN_DELAY))
        {
@@ -5,8 +5,8 @@ void shell_printf(const char *format, ...)
 {
    va_list ap;
    va_start(ap, format);
-    vsnprintf(__shell_shm + 1, SHELL_SHM_MAX, format, ap);
-    *__shell_shm = SHELL_PUTS;
+    vsnprintf(__shell_shm->data, sizeof(__shell_shm->data), format, ap);
+    __shell_shm->cmd = SHELL_PUTS;
    va_end(ap);
    __SHELL_WAIT();
 }
@@ -6,8 +6,8 @@ void shell_putc(char c)

    if (__shell_is_init == __SHELL_INIT_OK)
    {
-        *(__shell_shm + 1) = c;
-        *__shell_shm = SHELL_PUTC;
+        __shell_shm->data[0] = c;
+        __shell_shm->cmd = SHELL_PUTC;
        __SHELL_WAIT();
    }
 }
@@ -6,16 +6,16 @@ void shell_write_string(const char *s, size_t len)
    __shell_init();
    if (__shell_is_init == __SHELL_INIT_OK)
    {
-        if (len > SHELL_SHM_MAX - 1)
+        if (len > sizeof(__shell_shm->data) - 1)
        {
-            shell_write_string(s, SHELL_SHM_MAX - 1);                               // Outputs as much as it can.
-            shell_write_string(s + (SHELL_SHM_MAX - 1), len - (SHELL_SHM_MAX - 1)); // Outputs the rest.
+            shell_write_string(s, sizeof(__shell_shm->data) - 1);                               // Outputs as much as it can.
+            shell_write_string(s + (sizeof(__shell_shm->data) - 1), len - (sizeof(__shell_shm->data) - 1)); // Outputs the rest.
        }
        else
        {
-            memset(__shell_shm, 0, SHELL_SHM_MAX);  // without int shell show \t, \n, lose chars and other trash
-            memcpy(__shell_shm + 1, s, len);
-            *__shell_shm = SHELL_PUTS;
+            memset(__shell_shm->data, 0, sizeof(__shell_shm->data));  // without int shell show \t, \n, lose chars and other trash
+            memcpy(__shell_shm->data,  s, len);
+            __shell_shm->cmd = SHELL_PUTS;
            __SHELL_WAIT();
        }
    }
@@ -9,15 +9,17 @@
 #define __EXTERN extern
 #endif

-#define SHELL_OK   0
-#define SHELL_EXIT 1
-#define SHELL_PUTC 2
-#define SHELL_PUTS 3
-#define SHELL_GETC 4
-#define SHELL_GETS 5
-#define SHELL_CLS  6
-#define SHELL_PID  7
-#define SHELL_PING 8
+enum SHELL_API_COMMANDS {
+    SHELL_OK = 0,
+    SHELL_EXIT = 1,
+    SHELL_PUTC = 2,
+    SHELL_PUTS = 3,
+    SHELL_GETC = 4,
+    SHELL_GETS = 5,
+    SHELL_CLS = 6,
+    SHELL_PID = 7,
+    SHELL_PING = 8
+};

 #define SHELL_SHM_MAX 1024 * 16

@@ -28,15 +30,22 @@ enum __SHELL_INIT_STATE {
    __SHELL_INIT_FAILED = 3 // fail init shell
 };

+#pragma pack(push, 1)
+struct shell_shm_buffer {
+    uint8_t cmd;
+    char data[SHELL_SHM_MAX - sizeof(((struct shell_shm_buffer*)NULL)->cmd)];
+};
+#pragma pack(pop)
+
 __EXTERN char __shell_shm_name[32];
-__EXTERN char* __shell_shm;
+__EXTERN struct shell_shm_buffer* __shell_shm;
 __EXTERN enum __SHELL_INIT_STATE __shell_is_init;
 __EXTERN void __shell_init();

 #define __SHELL_WAIT()        \
    do {                      \
        _ksys_thread_yield(); \
-    } while (*__shell_shm);
+    } while (__shell_shm->cmd);

 __EXTERN int shell_ping();
 __EXTERN unsigned shell_get_pid();
@@ -52,4 +61,5 @@ __EXTERN void shell_printf(const char* format, ...);
 __EXTERN void shell_write_string(const char* s, size_t len);

 __EXTERN void shell_cls();
+
 #endif
@@ -1,11 +1,10 @@
 #ifndef _TIME_H_
 #define _TIME_H_

-#include <sys/ksys.h>
+#include <stddef.h>

 typedef unsigned long int clock_t;
 typedef unsigned long int time_t;
-#define clock()        _ksys_get_clock()
 #define CLOCKS_PER_SEC 100

 #pragma pack(push, 1)
@@ -22,6 +21,7 @@ struct tm {
 };
 #pragma pack(pop)

+DLLAPI clock_t clock(void);
 DLLAPI time_t mktime(struct tm* timeptr);
 DLLAPI time_t time(time_t* timer);
 DLLAPI struct tm* localtime(const time_t* timer);
@@ -119,6 +119,7 @@
 #include "math/sinh.c"
 #include "math/tanh.c"

+#include "time/clock.c"
 #include "time/asctime.c"
 #include "time/difftime.c"
 #include "time/localtime.c"
@@ -338,6 +339,7 @@ ksys_dll_t EXPORTS[] = {
    { "con_cls", &con_cls },
    { "con_get_cursor_pos", &con_get_cursor_pos },
    { "con_set_cursor_pos", &con_set_cursor_pos },
+    { "clock", &clock },
    { "mktime", &mktime },
    { "time", &time },
    { "localtime", &localtime },
@@ -0,0 +1,7 @@
+#include <time.h>
+#include <sys/ksys.h>
+
+clock_t clock(void)
+{
+    return _ksys_get_tick_count();
+}
@@ -1178,17 +1178,18 @@ proc png_colorspace_set_gamma, png_ptr:dword, colorspace:dword, gAMA:dword
 	; In 1.6.0 this test replaces the ones in pngrutil.c, in the gAMA chunk
 	; handling code, which only required the value to be >0.

+	png_debug 1, 'in png_colorspace_set_gamma'
 ;   charp errmsg;

 ;   if (gAMA < 16 || gAMA > 625000000)
 ;      errmsg = "gamma value out of range";

-;#  ifdef PNG_READ_gAMA_SUPPORTED
+if PNG_READ_gAMA_SUPPORTED eq 1
 	; Allow the application to set the gamma value more than once
 ;   else if ((png_ptr->mode & PNG_IS_READ_STRUCT) != 0 &&
 ;      (colorspace->flags & PNG_COLORSPACE_FROM_gAMA) != 0)
 ;      errmsg = "duplicate";
-;#  endif
+end if

 	; Do nothing if the colorspace is already invalid
 ;   else if ((colorspace->flags & PNG_COLORSPACE_INVALID) != 0)
@@ -161,8 +161,7 @@ proc png_set_gAMA_fixed uses eax edi esi, png_ptr:dword, info_ptr:dword, file_ga
 	or esi,esi
 	jz .end_f ;if (..== 0 || ..== 0) return

-	mov eax,esi
-	add eax,png_info_def.colorspace
+	lea eax,[esi+png_info_def.colorspace]
 	stdcall png_colorspace_set_gamma, edi, eax, [file_gamma]
 	stdcall png_colorspace_sync_info, edi, esi
 .end_f:
@@ -593,8 +592,10 @@ endp

 ;void (png_structrp png_ptr, png_inforp info_ptr, png_colorp palette, int num_palette)
 align 4
-proc png_set_PLTE uses eax edi esi, png_ptr:dword, info_ptr:dword, palette:dword, num_palette:dword
-;   uint_32 max_palette_length;
+proc png_set_PLTE uses eax ecx edi esi, png_ptr:dword, info_ptr:dword, palette:dword, num_palette:dword
+locals
+	max_palette_length rd 1 ;uint_32
+endl

 	png_debug1 1, 'in %s storage function', 'PLTE'

@@ -605,31 +606,53 @@ proc png_set_PLTE uses eax edi esi, png_ptr:dword, info_ptr:dword, palette:dword
 	or esi,esi
 	jz .end_f ;if (..==0 || ..==0) return

-;   max_palette_length = (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) ?
-;      (1 << info_ptr->bit_depth) : PNG_MAX_PALETTE_LENGTH;
+	;max_palette_length = (..==..) ? .. : ..
+	cmp byte[esi+png_info_def.color_type],PNG_COLOR_TYPE_PALETTE
+	jne @f
+		xor eax,eax
+		inc eax
+		movzx ecx,byte[esi+png_info_def.bit_depth]
+		shl eax,cl
+		mov [max_palette_length],eax
+		jmp .end0
+	@@:
+		mov [max_palette_length],PNG_MAX_PALETTE_LENGTH
+	.end0:

-;   if (num_palette < 0 || num_palette > (int) max_palette_length)
-;   {
-;      if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
-;         png_error(png_ptr, "Invalid palette length");
+	;if (..<0 || ..>..)
+	cmp [num_palette],0
+	jl @f
+	mov eax,[max_palette_length]
+	cmp [num_palette],eax
+	jle .end1
+	@@:
+	cmp byte[edi+png_struct.color_type],PNG_COLOR_TYPE_PALETTE ;if (..==..)
+	jne @f
+		png_error edi, 'Invalid palette length'
+		jmp .end1
+	@@: ;else
+		png_warning edi, 'Invalid palette length'
+		jmp .end_f
+	.end1:

-;      else
-;      {
-;         png_warning(png_ptr, "Invalid palette length");
-
-;         return;
-;      }
-;   }
-
-;   if ((num_palette > 0 && palette == NULL) ||
-;      (num_palette == 0
+	cmp [num_palette],0
+	jle @f
+	cmp [palette],0
+	je .end2
+	@@:
+	cmp [num_palette],0
+	jne .end3
+	;if ((..>0 && ..==0) || (..==0
 if PNG_MNG_FEATURES_SUPPORTED eq 1
-;            && (png_ptr->mng_features_permitted & PNG_FLAG_MNG_EMPTY_PLTE) == 0
+	; && (.. & PNG_FLAG_MNG_EMPTY_PLTE) == 0
+	mov eax,[edi+png_struct.mng_features_permitted]
+	and eax,PNG_FLAG_MNG_EMPTY_PLTE
+	jnz .end3
 end if
-;      ))
-;   {
-;      png_error(png_ptr, "Invalid palette");
-;   }
+	;))
+	.end2:
+		png_error edi, 'Invalid palette'
+	.end3:

 	; It may not actually be necessary to set png_ptr->palette here;
 	; we do it for backward compatibility with the way the png_handle_tRNS
@@ -644,14 +667,26 @@ end if
 	; of num_palette entries, in case of an invalid PNG file or incorrect
 	; call to png_set_PLTE() with too-large sample values.

-;   png_ptr->palette = png_calloc(png_ptr,
-;       PNG_MAX_PALETTE_LENGTH * (sizeof (png_color)));
+	stdcall png_calloc, edi, PNG_MAX_PALETTE_LENGTH*sizeof.png_color
+	mov [edi+png_struct.palette],eax

-;   if (num_palette > 0)
-;      memcpy(png_ptr->palette, palette, num_palette * (sizeof (png_color)));
+	;if (..>0)
+	cmp [num_palette],0
+	jle @f
+		push esi edi
+		mov ecx,[num_palette]
+		imul ecx,sizeof.png_color
+		mov esi,[palette]
+		mov edi,eax
+		rep movsb ;memcpy(png_ptr->palette, palette, ...
+		pop edi esi
+	@@:
 	mov eax,[edi+png_struct.palette]
 	mov [esi+png_info_def.palette],eax
-;   info_ptr->num_palette = png_ptr->num_palette = (uint_16)num_palette;
+
+	mov eax,[num_palette]
+	mov [edi+png_struct.num_palette],ax
+	mov [esi+png_info_def.num_palette],ax

 	or dword[esi+png_info_def.free_me], PNG_FREE_PLTE
 	or dword[esi+png_info_def.valid], PNG_INFO_PLTE
@@ -1925,6 +1925,7 @@ locals
 	aindex   dd 0 ;int  ;= 0
 	y dd ? ;uint_32 ;= image->height
 endl
+	png_debug 1, 'in png_write_image_16bit'
 	mov ebx,[argument]
 	mov [display],ebx
 	mov edx,[ebx+png_image_write_control.image]
@@ -2118,6 +2119,7 @@ locals
 	y dd ? ;uint_32 ;= image->height
 	component dd ? ;uint_32
 endl
+	png_debug 1, 'in png_write_image_8bit'
 	mov ebx,[argument]
 	mov [display],ebx
 	mov edx,[ebx+png_image_write_control.image]
@@ -2257,9 +2259,11 @@ locals
 	afirst dd 0
 	bgr dd 0
 	num_trans dd 0
+	i dd ?
 	palette rb 256*sizeof.png_color
 	tRNS rb 256 ;byte[]
 endl
+	png_debug 1, 'in png_image_set_PLTE'
 pushad
 	mov edx,[display]
 	mov ebx,[edx+png_image_write_control.image]
@@ -2296,30 +2300,33 @@ if PNG_FORMAT_BGR_SUPPORTED eq 1
 	@@:
 end if

-;   int i;
-
 	xor eax,eax
 	mov ecx,(256*sizeof.png_color)/4
-	mov edi,ebp
-	sub edi,256+256*sizeof.png_color
+	lea edi,[ebp-256-256*sizeof.png_color]
 	rep stosd ;memset(palette, 0, ...
 	not eax
 	mov ecx,256/4
-	;;mov edi,ebp ;if 'tRNS' after 'palette' this code can be comment
-	;;sub edi,256
+	;lea edi,[ebp-256] ;if 'tRNS' after 'palette' this code can be comment
 	rep stosd ;memset(tRNS, 255, ...

-
-;   for (i=num_trans=0; i<entries; ++i)
-;   {
+	mov [i],0
+	lea edx,[ebp-256] ;edx=&tRNS
+	lea edi,[edx-256*sizeof.png_color]
+align 4
+	.cycle0: ;for (i=num_trans=0; i<entries; ++i)
 		; This gets automatically converted to sRGB with reversal of the
 		; pre-multiplication if the color-map has an alpha channel.

-;      if ((format & PNG_FORMAT_FLAG_LINEAR) != 0)
-;      {
-;         png_const_uint_16p entry = cmap;
-
-;         entry += i * channels;
+		;if ((..&..) != 0)
+		mov eax,[format]
+		and eax,PNG_FORMAT_FLAG_LINEAR
+		or eax,eax
+		jz .end0
+			mov esi,[cmap] ;esi=entry uint_16p
+			mov eax,[channels]
+			mov ecx,eax
+			imul eax,[i]
+			add esi,eax ;+=i*channels;

 ;         if ((channels & 1) != 0) /* no alpha */
 ;         {
@@ -2369,46 +2376,86 @@ end if
 ;               palette[i].blue = palette[i].red = palette[i].green =
 ;                   png_unpremultiply(entry[afirst], alpha, reciprocal);
 ;         }
-;      }
+			jmp .end1
+		.end0: ;else Color-map has sRGB values
+			mov esi,[cmap] ;esi=entry
+			mov eax,[channels]
+			mov ecx,eax
+			imul eax,[i]
+			add esi,eax ;+=i*channels;

-;      else /* Color-map has sRGB values */
-;      {
-;         bytep entry = cmap;
+			;switch (channels)
+			cmp ecx,4
+			jne .end2
+				mov eax,[afirst]
+				or eax,eax
+				jz @f
+					xor eax,eax
+					jmp .end3
+				@@:
+					mov eax,3
+				.end3:
+				mov al,byte[esi+eax]
+				mov byte[edx],al ;tRNS[i] = entry[afirst ? 0 : 3]
+				cmp al,255 ;if (..<..)
+				je @f
+					mov eax,[i]
+					inc eax
+					mov [num_trans],eax
+				@@:
+				dec ecx ; FALL THROUGH
+			.end2:
+			cmp ecx,3
+			jne @f
+				add esi,[afirst]
+				mov eax,[bgr]
+				xor eax,2
+				lea eax,[esi+eax]
+				mov al,byte[eax]
+				stosb ;palette[i].blue

-;         entry += i * channels;
+				lea eax,[esi+1]
+				mov al,byte[eax]
+				stosb ;palette[i].green

-;         switch (channels)
-;         {
-;            case 4:
-;               tRNS[i] = entry[afirst ? 0 : 3];
-;               if (tRNS[i] < 255)
-;                  num_trans = i+1;
-;               /* FALL THROUGH */
-;            case 3:
-;               palette[i].blue = entry[afirst + (2 ^ bgr)];
-;               palette[i].green = entry[afirst + 1];
-;               palette[i].red = entry[afirst + bgr];
-;               break;
-
-;            case 2:
-;               tRNS[i] = entry[1 ^ afirst];
-;               if (tRNS[i] < 255)
-;                  num_trans = i+1;
-;               /* FALL THROUGH */
-;            case 1:
-;               palette[i].blue = palette[i].red = palette[i].green =
-;                  entry[afirst];
-;               break;
-
-;            default:
-;               break;
-;         }
-;      }
-;   }
+				mov eax,[bgr]
+				lea eax,[esi+eax]
+				mov al,byte[eax]
+				stosb ;palette[i].red
+				jmp .end1
+			@@:
+			cmp ecx,2
+			jne @f
+				xor eax,eax
+				inc eax
+				xor eax,[afirst]
+				mov al,byte[esi+eax]
+				mov byte[edx],al  ;tRNS[i] = entry[1 ^ afirst]
+				cmp al,255 ;if (..<..)
+				je @f
+					mov eax,[i]
+					inc eax
+					mov [num_trans],eax
+				@@:
+				dec ecx; FALL THROUGH
+			@@:
+			cmp ecx,1
+			jne .end1
+				mov eax,[afirst]
+				mov al,byte[esi+eax]
+				stosb
+				stosb
+				stosb
+		.end1:
+		inc edx
+		mov eax,[entries]
+		inc [i]
+		cmp [i],eax
+		jl .cycle0
+	.cycle0end:

 	mov ecx,[ebx+png_image.opaque]
-	mov eax,ebp
-	sub eax,256+256*sizeof.png_color
+	lea eax,[ebp-256-256*sizeof.png_color]
 	stdcall png_set_PLTE, [ecx+png_control.png_ptr], [ecx+png_control.info_ptr], eax, [entries]

 	cmp dword[num_trans],0
@@ -2820,9 +2867,26 @@ png_debug1 2, 'IDAT compress all len = %d', [len]
 	mov edi,[buf_f]
 	mov esi,[buf]
 	
+	cmp eax,PNG_COLOR_TYPE_PALETTE
+	je .cycle7
+	cmp eax,PNG_COLOR_TYPE_RGB
+	je .cycle0
 	cmp eax,PNG_COLOR_TYPE_RGB_ALPHA
 	je .cycle5
 	
+	.cycle7: ;8 bit image palette
+	cmp edx,1
+	jl .cycle0end
+		mov ecx,ebx
+		xor al,al
+		stosb ;insert filter (0 - none)
+align 4
+		rep movsb
+		dec edx
+		jmp .cycle7
+	.cycle7end:
+	jmp .cycle5end
+
 	.cycle0: ;24 bit image
 	cmp edx,1
 	jl .cycle0end
@@ -1063,8 +1063,8 @@ align 4
 proc png_write_PLTE, png_ptr:dword, palette:dword, num_pal:dword
 locals
 	;max_palette_length dd ? ;uint_32
-	i dd ?
-	pal_ptr dd ? ;png_const_colorp
+	;i dd ?
+	;pal_ptr dd ? ;png_const_colorp
 	buf rb 3 ;byte[3]
 endl
 	png_debug 1, 'in png_write_PLTE'
@@ -1085,16 +1085,16 @@ pushad
 		;mov [max_palette_length],eax
 	.end0:

-if PNG_MNG_FEATURES_SUPPORTED eq 1
 	cmp [num_pal],eax
 	jg @f
+if PNG_MNG_FEATURES_SUPPORTED eq 1
 	mov eax,[edi+png_struct.mng_features_permitted]
 	and eax,PNG_FLAG_MNG_EMPTY_PLTE
 	jnz .end1
+end if
 	cmp [num_pal],0
 	jne .end1
 	@@:
-end if

 	cmp byte[edi+png_struct.color_type],PNG_COLOR_TYPE_PALETTE ;if (..==..)
 	jne @f
@@ -1118,31 +1118,24 @@ end if

 	imul eax,3
 	stdcall png_write_chunk_header, edi, png_PLTE, eax
-if PNG_POINTER_INDEXING_SUPPORTED eq 1

-;   for (i = 0, pal_ptr = palette; i < num_pal; i++, pal_ptr++)
-;   {
-;      buf[0] = pal_ptr->red;
-;      buf[1] = pal_ptr->green;
-;      buf[2] = pal_ptr->blue;
-;      png_write_chunk_data(png_ptr, buf, (png_size_t)3);
-;   }
+	mov ecx,[num_pal]
+	or ecx,ecx
+	jz .cycle0end
+	mov esi,[palette]
+	lea ebx,[ebp-3] ;ebx = &buf
+align 4
+	.cycle0: ;for (;;)
+		lodsb
+		mov [ebx],al
+		lodsb
+		mov [ebx+1],al
+		lodsb
+		mov [ebx+2],al
+		stdcall png_write_chunk_data, edi, ebx, 3
+		loop .cycle0
+	.cycle0end:

-else
-	; This is a little slower but some buggy compilers need to do this
-	; instead
-
-;   pal_ptr=palette;
-
-;   for (i = 0; i < num_pal; i++)
-;   {
-;      buf[0] = pal_ptr[i].red;
-;      buf[1] = pal_ptr[i].green;
-;      buf[2] = pal_ptr[i].blue;
-;      png_write_chunk_data(png_ptr, buf, (png_size_t)3);
-;   }
-
-end if
 	stdcall png_write_chunk_end, edi
 	or dword[edi+png_struct.mode], PNG_HAVE_PLTE
 .end_f:
@@ -1163,7 +1163,7 @@ local .l1

 ;;================================================================================================;;
 align 4
-proc img.encode.png uses ebx edx, _img:dword, _common:dword, _specific:dword
+proc img.encode.png uses ebx edx edi, _img:dword, _common:dword, _specific:dword
 ;;------------------------------------------------------------------------------------------------;;
 ;? Encode image into raw data in png format                                                       ;;
 ;;------------------------------------------------------------------------------------------------;;
@@ -1175,12 +1175,15 @@ proc img.encode.png uses ebx edx, _img:dword, _common:dword, _specific:dword
 ;< ecx = error code / the size of encoded data                                                    ;;
 ;;================================================================================================;;
 locals
+	colormap dd 0
 	encoded_file rd 1
 	encoded_file_size rd 1
 	simag png_image
 endl
 	mov ebx,[_img]
 	mov	eax,[ebx+Image.Type]
+	cmp	eax,Image.bpp8i
+	je @f
 	cmp	eax,Image.bpp24
 	je @f
 	cmp	eax,Image.bpp32
@@ -1192,16 +1195,27 @@ endl
 	mov dword[edx+png_image.version],PNG_IMAGE_VERSION
 	mov ecx,[ebx+Image.Width]
 	mov [edx+png_image.width],ecx ;Image width in pixels (columns)
+	cmp	eax,Image.bpp8i
+	jne @f
+		mov dword[edx+png_image.format],PNG_FORMAT_RGBA_COLORMAP
+		mov eax,ecx
+		imul eax,[ebx+Image.Height]
+		add eax,[ebx+Image.Data]
+		add [colormap],eax
+		stdcall get_pallete_colors,eax
+		mov dword[edx+png_image.colormap_entries],eax
+		jmp .init
+	@@:
 	cmp	eax,Image.bpp24
 	jne @f
 		mov dword[edx+png_image.format],PNG_FORMAT_RGB
 		imul ecx,3
 	@@:
 	cmp	eax,Image.bpp32
-	jne @f
+	jne .init
 		mov dword[edx+png_image.format],PNG_FORMAT_RGBA
 		shl ecx,2
-	@@:
+.init:
 	mov eax,[ebx+Image.Height]
 	mov [edx+png_image.height],eax ;Image height in pixels (rows)
 	;mov dword[edx+png_image.flags],PNG_IMAGE_FLAG_???
@@ -1221,7 +1235,7 @@ endl
    @@:
 	mov [encoded_file],eax
 	lea edi,[edx-4]
-	stdcall png_image_write_to_memory, edx,eax,edi,0,[ebx+Image.Data],ecx,0
+	stdcall png_image_write_to_memory, edx,eax,edi,0,[ebx+Image.Data],ecx,[colormap]
 	mov	eax,[encoded_file]
 	mov	ecx,[encoded_file_size]
 	jmp	.quit
@@ -1231,3 +1245,31 @@ endl
 .quit:
 	ret
 endp
+
+
+
+;;================================================================================================;;
+align 4
+proc get_pallete_colors uses ecx edi, palette:dword
+;;------------------------------------------------------------------------------------------------;;
+;? Determine the palette size. Locate two adjacent zero-value colors;                             ;;
+;? this marks the end of the palette.                                                             ;;
+;;------------------------------------------------------------------------------------------------;;
+	mov ecx,256-1
+	mov edi,[palette]
+	xor eax,eax
+@@:
+	repne scasd
+	or ecx,ecx
+	jz .max_pal
+	cmp [edi],eax ;second color check
+	jne @b        ;find again
+	sub edi,[palette]
+	shr edi,2
+	mov eax,edi
+	jmp @f
+.max_pal:
+	mov eax,256
+@@:
+	ret
+endp
@@ -913,7 +913,7 @@ static off_t get_fileinfo(struct reader *rds,char *buf)
 	#define syncsafe_to_long(buf,res) \
 	( \
 		(((buf)[0]|(buf)[1]|(buf)[2]|(buf)[3]) & 0x80) ? 0 : \
-		(res =  (((unsigned long) (buf)[0]) << 27) \
+		(res =  (((unsigned long) (buf)[0]) << 21) \
 		     | (((unsigned long) (buf)[1]) << 14) \
 		     | (((unsigned long) (buf)[2]) << 7) \
 		     |  ((unsigned long) (buf)[3]) \
@@ -202,6 +202,8 @@ mainloop:
        mov     bh, byte[ebp + interface.number]
        mov     bl, 7
        mcall   76                      ; Number of IP conflicts
+        cmp     eax, -1
+        je      @f
        cmp     eax, [ebp + interface.ip_conflicts]
        je      @f
        mov     [ebp + interface.ip_conflicts], eax
@@ -215,8 +217,8 @@ mainloop:
        mov     bh, byte[ebp + interface.number]
        mov     bl, 0                   ; Get device type
        mcall   74
-        test    eax, eax                ; No device
-        jz      .link_down
+        cmp     eax, 1
+        jne     .link_down

 ; Check if link is still there
        mov     bl, 10                  ; Get Link status
@@ -189,6 +189,8 @@ key:
        mcall   2
        cmp     ah, ' '
        je      button.noclose
+        cmp     ah, 9                     ; Tab
+        je      button.noclose
        cmp     ah, 51 ; F2
        je      open_boardlog
        jmp     still
Author	SHA1	Message	Date
Leency	ecd62148de	drivers/video/drm: add drm_encoder_slave.c for nouveau Test PR / Build (ru_RU) (pull_request) Successful in 2m56s Details Test PR / Build (es_ES) (pull_request) Successful in 3m2s Details Test PR / Build (en_US) (pull_request) Successful in 3m8s Details The nouveau port builds it with the DRM core: dispnv04 drives its TV and TMDS encoders through the drm_i2c_encoder_* slave API. The matching drm/drm_encoder_slave.h is already in drivers/include. Assisted-by: Claude Opus 5 <noreply@anthropic.com>	2026-09-15 05:12:27 +03:00
Leency	cbd8970197	drivers/include: backport Linux 4.9 bits for amdgpu and nouveau Test PR / Build (ru_RU) (pull_request) Successful in 3m15s Details Test PR / Build (es_ES) (pull_request) Successful in 3m18s Details Test PR / Build (en_US) (pull_request) Successful in 3m21s Details The headers stay Linux 4.6.x, which the tree's DRM core is built on. These are small additive backports from Linux 4.9 (4.9.337) needed to build the amdgpu and nouveau ports. Modified headers only gain missing struct fields, prototypes and macros. New headers are minimal stubs, plus a few files taken from Linux 4.9: kfifo.h, amdgpu_drm.h, nouveau_drm.h, drm_encoder_slave.h, i2c/ch7006.h, i2c/sil164.h, fence-array.h. Assisted-by: Claude Opus 5 <noreply@anthropic.com>	2026-09-13 23:22:08 +03:00
Leency	7802c7b18a	fat: fix stack imbalance on fatal hd_extend_file error (#631 ) Build system / Build (en_US) (push) Successful in 3m6s Details Build system / Build (es_ES) (push) Successful in 3m17s Details Build system / Build (ru_RU) (push) Successful in 3m23s Details Build system / Publish Images (push) Successful in 3m19s Details The FAT/device error path in fat_Write jumped to the shared one-dword epilogue with four dwords live, so ret returned into the error-code slot and faulted in ring 0. Give the path its own named label. Reviewed-on: #631 Reviewed-by: Burer <burer@kolibrios.org> Reviewed-by: Mikhail Frolov <mixa.frolov2003@gmail.com>	2026-09-12 21:25:21 +00:00
Leency	8a94db94a5	remove comments Check kernel codestyle / Check kernel codestyle (pull_request) Successful in 17s Details Test PR / Build (en_US) (pull_request) Successful in 2m18s Details Test PR / Build (es_ES) (pull_request) Successful in 2m21s Details Test PR / Build (ru_RU) (pull_request) Successful in 2m22s Details Build system / Build (en_US) (push) Successful in 2m53s Details Build system / Build (es_ES) (push) Successful in 2m56s Details Build system / Build (ru_RU) (push) Successful in 3m0s Details Build system / Publish Images (push) Successful in 4m58s Details	2026-09-11 18:51:30 +00:00
LeencyandClaude Opus 5	513af11464	kernel/net: raise the socket buffer size to 128 KiB Summary: SOCKET_BUFFER_SIZE was 32 KiB, which caps a single TCP connection at roughly 1 MB/s over a typical internet path regardless of the available bandwidth. Подробно: The receive buffer size is the upper bound on the window a socket can advertise, and a TCP connection cannot go faster than window / RTT. At the old 40968 = 32 KiB, a path with a 32 ms round trip is limited to about 1 MB/s no matter how fast the link underneath is. Raising the buffer to 409632 = 128 KiB moves that ceiling to roughly 4 MB/s on the same path. Nothing else needs adjusting: request_r_scale is derived from SOCKET_BUFFER_SIZE in tcp_usreq, so the window scale we request grows with the buffer automatically, and both tcp_output and tcp_respond clamp the scaled value to the 16-bit header field. The constant keeps satisfying the documented requirement of 4096*(power of two >= 8). The cost is memory: each stream socket maps a send and a receive ring, so a TCP socket now reserves 256 KiB of physical memory instead of 64 KiB (and twice that in address space, since the rings are mirror-mapped). For a browser holding a handful of connections open this is a few megabytes. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>	2026-09-11 18:51:30 +00:00
Egor00f	e0e8a35364	`libc.obj`: `time.h` using `_ksys_get_clock`, but this function not defined (#688 ) Build system / Build (en_US) (push) Successful in 3m30s Details Build system / Build (ru_RU) (push) Successful in 3m30s Details Build system / Build (es_ES) (push) Successful in 3m38s Details Build system / Publish Images (push) Successful in 3m13s Details `f2ea10c1cd/programs/develop/ktcc/libc.obj/include/time.h (L8)` Reviewed-on: #688 Co-authored-by: Egor00f <y.yarin@inbox.ru>	2026-09-08 20:41:45 +00:00
Matou1306	f2ea10c1cd	fs/ext: Support INCOMPAT_EXTENTS, RO_COMPAT_DIR_NLINK, RO_COMPAT_HUGE_FILE. (#603 ) Build system / Build (en_US) (push) Successful in 3m14s Details Build system / Build (ru_RU) (push) Successful in 3m18s Details Build system / Build (es_ES) (push) Successful in 3m23s Details Build system / Publish Images (push) Successful in 3m40s Details Extents writing support. In addition, the file system can now write to file systems with dir_nlink, as long as the target directory doesn't have the index flag enabled (directories exceeding 64k subdirectories). It also supports huge_file, as long as the huge_file inode flag is not enabled on the file itself (files > 2TB). This Pull Request depends on #584 What currently works: - Merging a new allocation into the last extent when contiguous (.extentNext fast path) - Adding a new extent entry into an existing leaf/root node that still has room (.addNewExtent) - Creating the very first extent in an empty root (.newExtentRoot) - Checksum maintenance via calc_extent_block_csum on writes to index/leaf blocks - Truncation, including freeing leaves and collapsing an index entry back up the tree (.trim_tree/.trim_index), down to setting currentDepth = 0 when the whole tree empties - Increasing the height of the tree and allocating new leaves. Reviewed-on: #603 Reviewed-by: Burer <burer@kolibrios.org> Reviewed-by: Mikhail Frolov <mixa.frolov2003@gmail.com> Co-authored-by: Matou1306 <mathieubotros@gmail.com>	2026-09-07 11:41:41 +00:00
Leency	302bf7e221	board: toggle kernel/user log with Tab (#682 ) Build system / Build (ru_RU) (push) Successful in 3m56s Details Build system / Build (en_US) (push) Successful in 4m1s Details Build system / Build (es_ES) (push) Successful in 4m3s Details Build system / Publish Images (push) Successful in 4m22s Details Reviewed-on: #682 Reviewed-by: Burer <burer@kolibrios.org> Reviewed-by: Mikhail Frolov <mixa.frolov2003@gmail.com> Co-authored-by: leency <lipatov.kiril@gmail.com>	2026-09-07 11:20:29 +00:00
IgorA	a3af661ed6	libs/libimg: added support for saving 8-bit images in PNG format (#599 ) Build system / Build (ru_RU) (push) Successful in 4m7s Details Build system / Build (en_US) (push) Successful in 4m15s Details Build system / Build (es_ES) (push) Successful in 4m23s Details Build system / Publish Images (push) Successful in 4m10s Details Еxample of an 8-bit png image with a palette https://git.kolibrios.org/KolibriOS/kolibrios/src/branch/main/programs/develop/libraries/TinyGL/asm_fork/examples/text_2.png Reviewed-on: #599 Reviewed-by: Burer <burer@kolibrios.org> Reviewed-by: Mikhail Frolov <mixa.frolov2003@gmail.com> Co-authored-by: IgorA <aie85playm@gmail.com>	2026-09-07 11:14:21 +00:00
b00bl1k	e74f989500	programs/system/terminal: switch to the serial driver (#638 ) Build system / Build (es_ES) (push) Successful in 5m59s Details Build system / Build (en_US) (push) Successful in 6m15s Details Build system / Build (ru_RU) (push) Successful in 6m15s Details Build system / Publish Images (push) Successful in 4m44s Details Reworks Terminal to use the drivers/serial API instead of using UART registers directly, enabling virtual COM port (VCP) support in addition to physical ports. - port field now accepts a numeric port id instead of a COMx name - syscalls use `SF_`/`SSF_` named constants Closes #604 Reviewed-on: #638 Reviewed-by: Burer <burer@kolibrios.org> Reviewed-by: Mikhail Frolov <mixa.frolov2003@gmail.com> Co-authored-by: Alexey Ryabov <alex@b00bl1k.ru>	2026-09-07 10:37:40 +00:00
Leency	4fe3987e39	drivers/usbstor: limit one SCSI transfer to 240 sectors (#686 ) Build system / Build (es_ES) (push) Successful in 4m3s Details Build system / Build (en_US) (push) Successful in 4m3s Details Build system / Build (ru_RU) (push) Successful in 4m5s Details Build system / Publish Images (push) Successful in 4m8s Details max_sectors_at_time only bounded a slice by the 16-bit transfer length field of READ(10)/WRITE(10), i.e. 32 MB, so whatever the caller asked for went to the device as a single command. The kernel disk cache hands the driver up to CACHE_MAX_ALLOC_SIZE (4 MB) at once, so reading any file larger than 4 MB produced one 4 MB bulk transfer. USB sticks do not see such commands from other systems and some of them wedge their firmware on it: the queue halts with XactErr and an exhausted error counter, the device stops answering, drops off the bus and re-enumerates in the middle of the operation. Observed on two different sticks, reproducible on every file over 4 MB. Cap a slice at 240 sectors (120 KB), the limit Linux usb-storage uses for the same reason. The splitting loop was already there. Assisted-by: Claude Opus 5 <noreply@anthropic.com> Reviewed-on: #686 Reviewed-by: Mikhail Frolov <mixa.frolov2003@gmail.com> Reviewed-by: Burer <burer@kolibrios.org> Co-authored-by: leency <lipatov.kiril@gmail.com>	2026-09-07 07:45:25 +00:00
Sweetbread	060ec1a5d0	chore: codeowners Test PR / Build (es_ES) (pull_request) Successful in 2m30s Details Test PR / Build (en_US) (pull_request) Successful in 2m43s Details Test PR / Build (ru_RU) (pull_request) Successful in 2m55s Details Build system / Build (es_ES) (push) Successful in 4m49s Details Build system / Build (en_US) (push) Successful in 4m57s Details Build system / Build (ru_RU) (push) Successful in 4m56s Details Build system / Publish Images (push) Successful in 3m57s Details	2026-09-03 11:59:18 +00:00
Sweetbread	882f1f0242	ci: use builtin GITEA_TOKEN Test PR / Build (en_US) (pull_request) Successful in 1m52s Details Test PR / Build (es_ES) (pull_request) Successful in 1m59s Details Test PR / Build (ru_RU) (pull_request) Successful in 2m3s Details Build system / Build (en_US) (push) Successful in 3m3s Details Build system / Build (es_ES) (push) Successful in 3m6s Details Build system / Build (ru_RU) (push) Successful in 3m10s Details Build system / Publish Images (push) Successful in 3m47s Details	2026-09-03 11:48:08 +00:00
Leency	02070aa233	zeroconf: do not report IP conflict when device is gone (#677 ) Build system / Build (en_US) (push) Successful in 3m30s Details Build system / Build (es_ES) (push) Successful in 3m34s Details Build system / Build (ru_RU) (push) Successful in 3m37s Details Build system / Publish Images (push) Successful in 4m5s Details Sysfn 76 returns -1 for a missing device. The ARP conflict counter check in .maintain_link treats any change of the value as a new conflict, so when a device disappeared the counter jumped 0 -> -1 -> 0 across the reconnect and a bogus "IP address conflict" notification popped up on every replug of a USB network device. Skip the check when the query fails. Assisted-by: Claude Opus 5 <noreply@anthropic.com> Reviewed-on: #677 Reviewed-by: hidnplayr <hidnplayr@gmail.com> Reviewed-by: Burer <burer@kolibrios.org> Co-authored-by: leency <lipatov.kiril@gmail.com>	2026-09-03 10:12:36 +00:00
Burer	d0244f1513	apps/oberon07: migrate submodule to gitea (#680 ) Build system / Build (en_US) (push) Successful in 3m34s Details Build system / Build (es_ES) (push) Successful in 3m49s Details Build system / Build (ru_RU) (push) Successful in 3m54s Details Build system / Publish Images (push) Successful in 4m37s Details Reviewed-on: #680 Reviewed-by: Егор Ярин <y.yarin@inbox.ru> Reviewed-by: Kiril Lipatov <lipatov.kiril@gmail.com> Reviewed-by: Gleb Zaharov <risdeveau@lair.moe>	2026-09-03 10:06:44 +00:00
Leency	44465b3cc2	zeroconf: restart DHCP after network device removal (#676 ) Build system / Build (ru_RU) (push) Successful in 4m23s Details Build system / Build (en_US) (push) Successful in 4m40s Details Build system / Build (es_ES) (push) Successful in 4m47s Details Build system / Publish Images (push) Successful in 5m3s Details Sysfn 74 returns -1 for a missing device, not 0, so the device-presence check in .maintain_link never took the .link_down path and the interface stayed in connected state forever. As a result DHCP was never restarted when a device reappeared on the same slot (e.g. an Android phone re-enumerating in RNDIS tethering mode with a new random MAC), leaving the interface with a stale IP and a dead gateway. Compare against 1 (Ethernet), the same way the .link_up? path already does, so a vanished device properly resets the interface state and DHCP runs again on reconnect. Assisted-by: Claude Opus 5 <noreply@anthropic.com> Reviewed-on: #676 Reviewed-by: hidnplayr <hidnplayr@gmail.com> Reviewed-by: Burer <burer@kolibrios.org> Co-authored-by: leency <lipatov.kiril@gmail.com>	2026-09-03 09:51:49 +00:00
Egor00f	1df9d8496d	`libshell` & `shell`: use `shell_api.h` (#657 ) Build system / Build (es_ES) (push) Successful in 3m46s Details Build system / Build (en_US) (push) Successful in 3m55s Details Build system / Build (ru_RU) (push) Successful in 4m27s Details Build system / Publish Images (push) Successful in 5m28s Details Use `shell_api.h` and the buffer structure in `shell` and `libshell` to avoid magic numbers and sync Reviewed-on: #657 Reviewed-by: Burer <burer@kolibrios.org> Co-authored-by: Egor00f <y.yarin@inbox.ru>	2026-09-02 08:25:57 +00:00
Leency	7917972a37	ac97snd: fix bug to play Cactus mp3 Build system / Build (en_US) (push) Successful in 3m16s Details Build system / Publish Images (push) Successful in 15m36s Details Test PR / Build (en_US) (pull_request) Successful in 1m54s Details Test PR / Build (ru_RU) (pull_request) Successful in 2m4s Details Test PR / Build (es_ES) (pull_request) Successful in 2m8s Details Build system / Build (es_ES) (push) Successful in 3m9s Details Build system / Build (ru_RU) (push) Successful in 3m13s Details	2026-09-01 22:48:45 +03:00
Burerandkolibrios-bot Bot	8334324d9c	chore/submodules: bump kterm to upstream (#670 ) Build system / Build (en_US) (push) Successful in 4m11s Details Build system / Build (es_ES) (push) Successful in 4m19s Details Build system / Build (ru_RU) (push) Successful in 4m26s Details Build system / Publish Images (push) Successful in 5m10s Details Co-authored-by: kolibri-bot <bot@kolibrios.org> Reviewed-on: #670 Reviewed-by: Mikhail Frolov <mixa.frolov2003@gmail.com> Reviewed-by: Ivan B <1+dunkaist@noreply.localhost>	2026-09-01 14:33:53 +00:00
ZReticules Burer ZReticules	2757ea7d3e	libs/boxlib: rewrite editbox.asm (fix #652 ) (#662 ) Build system / Build (en_US) (push) Successful in 3m35s Details Build system / Build (es_ES) (push) Successful in 3m39s Details Build system / Build (ru_RU) (push) Successful in 3m48s Details Build system / Publish Images (push) Successful in 6m56s Details Rewrite of the editbox widget. Binary layout and public API unchanged. - much more readable code - scroll step = actual chars that fit in the field (`visibleCount`, ex-`shift_old`), not hardcoded 8 (fixes #652) - `edit_box` formalized as a fasm `struct` with named fields; unions add readable aliases (`caretPos`, `textLen`, `selectColor`, ...) to the old names - `txCol` -> `txColor` (`BColor` union with per-channel access) - clipboard: payload described by `BClipBuf` struct, content validated before paste, fixed paste arithmetic and a memory leak on read - restored Ctrl+C - fixed `not cx` truncation (buffer overflow), stale redraw in insert mode, division with uninitialized edx - control flow untangled into procedures, net -94 lines --------- Co-authored-by: Burer <burer@kolibrios.org> Co-authored-by: ZReticules <my_mailbox_228@mail.ru> Reviewed-on: #662 Reviewed-by: IgorA <22+igora@noreply.localhost> Reviewed-by: Mikhail Frolov <mixa.frolov2003@gmail.com> Reviewed-by: Burer <burer@kolibrios.org> Co-authored-by: The Bird of Hermes <zlo.shustrik@mail.ru>	2026-09-01 14:26:21 +00:00
Burer	bf8ae67dbf	ci: restore functionality of old autobuilds system (#671 ) Build system / Build (es_ES) (push) Successful in 3m35s Details Build system / Publish Images (push) Successful in 4m48s Details Build system / Build (ru_RU) (push) Successful in 3m39s Details Build system / Build (en_US) (push) Successful in 3m44s Details Restores what the new ci/ folder lost compared to the old autobuild server: - `ci/latest` symlink to the newest build - bare `kolibri.img` at `<lang>/data/data/kolibri.img` - the path emulators (v86) hardcode - `distr.tar.gz` (distribution kit) - build tree unpacked into `ci/<version>/<lang>/data/` for per-program downloads - `sha256sums.txt` and `build.log` per language Reviewed-on: #671 Reviewed-by: Gleb Zaharov <risdeveau@lair.moe> Reviewed-by: Mikhail Frolov <mixa.frolov2003@gmail.com> Co-authored-by: Burer <burer@kolibrios.org>	2026-09-01 15:02:56 +03:00
Leency	69bd99e991	kernel: check kernel_alloc result in font.inc (#663 ) Build system / Build (en_US) (push) Successful in 2m27s Details Build system / Build (ru_RU) (push) Successful in 2m32s Details Build system / Build (es_ES) (push) Successful in 2m39s Details Build system / Publish Images (push) Successful in 1m59s Details This avoid taskbar and other apps crash when no free mem. Reviewed-on: #663 Reviewed-by: Burer <burer@kolibrios.org> Reviewed-by: Mikhail Frolov <mixa.frolov2003@gmail.com> Co-authored-by: leency <lipatov.kiril@gmail.com>	2026-08-31 12:21:10 +00:00
weronika-saturday	3bde56821f	data/skins: Zune skin from WindowsXP for KolibriOS (#665 ) Build system / Publish Images (push) Successful in 3m3s Details Build system / Build (es_ES) (push) Successful in 2m21s Details Build system / Build (en_US) (push) Successful in 2m24s Details Build system / Build (ru_RU) (push) Successful in 2m27s Details Today is the 20th anniversary of Microsoft’s Zune player. I ported the theme of Zune from Windows XP. This is my first experience in creating skins for KolibriOS. Reviewed-on: #665 Reviewed-by: Kiril Lipatov <lipatov.kiril@gmail.com> Reviewed-by: Alexey Ryabov <alex@b00bl1k.ru> Co-authored-by: Weronika Saturday <saturdayweronika@gmail.com>	2026-08-30 06:53:56 +00:00