Adding debian version 5.10.209-2.debian/5.10.209-2

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 179 insertions, 0 deletions

diff --git a/debian/patches-rt/0049-io-mapping-Provide-iomap_local-variant.patch b/debian/patches-rt/0049-io-mapping-Provide-iomap_local-variant.patch
new file mode 100644
index 000000000..1419b16fb
--- /dev/null
+++ b/debian/patches-rt/0049-io-mapping-Provide-iomap_local-variant.patch
@@ -0,0 +1,179 @@
+From 223ef1707ad3b008f96df3f4d263d2cdeed3ef65 Mon Sep 17 00:00:00 2001
+From: Thomas Gleixner <tglx@linutronix.de>
+Date: Tue, 3 Nov 2020 10:27:38 +0100
+Subject: [PATCH 049/323] io-mapping: Provide iomap_local variant
+Origin: https://www.kernel.org/pub/linux/kernel/projects/rt/5.10/older/patches-5.10.204-rt100.tar.xz
+
+Similar to kmap local provide a iomap local variant which only disables
+migration, but neither disables pagefaults nor preemption.
+
+Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
+Signed-off-by: Sebastian Andrzej Siewior <bigeasy@linutronix.de>
+---
+ Documentation/driver-api/io-mapping.rst | 74 +++++++++++++++----------
+ include/linux/io-mapping.h              | 30 +++++++++-
+ 2 files changed, 73 insertions(+), 31 deletions(-)
+
+diff --git a/Documentation/driver-api/io-mapping.rst b/Documentation/driver-api/io-mapping.rst
+index e33b88268554..a0cfb15988df 100644
+--- a/Documentation/driver-api/io-mapping.rst
++++ b/Documentation/driver-api/io-mapping.rst
+@@ -20,55 +20,71 @@ A mapping object is created during driver initialization using::
+ mappable, while 'size' indicates how large a mapping region to
+ enable. Both are in bytes.
+ 
+-This _wc variant provides a mapping which may only be used
+-with the io_mapping_map_atomic_wc or io_mapping_map_wc.
++This _wc variant provides a mapping which may only be used with
++io_mapping_map_atomic_wc(), io_mapping_map_local_wc() or
++io_mapping_map_wc().
+ 
+-With this mapping object, individual pages can be mapped either atomically
+-or not, depending on the necessary scheduling environment. Of course, atomic
+-maps are more efficient::
++With this mapping object, individual pages can be mapped either temporarily
++or long term, depending on the requirements. Of course, temporary maps are
++more efficient. They come in two flavours::
++
++	void *io_mapping_map_local_wc(struct io_mapping *mapping,
++				      unsigned long offset)
+ 
+ 	void *io_mapping_map_atomic_wc(struct io_mapping *mapping,
+ 				       unsigned long offset)
+ 
+-'offset' is the offset within the defined mapping region.
+-Accessing addresses beyond the region specified in the
+-creation function yields undefined results. Using an offset
+-which is not page aligned yields an undefined result. The
+-return value points to a single page in CPU address space.
++'offset' is the offset within the defined mapping region.  Accessing
++addresses beyond the region specified in the creation function yields
++undefined results. Using an offset which is not page aligned yields an
++undefined result. The return value points to a single page in CPU address
++space.
+ 
+-This _wc variant returns a write-combining map to the
+-page and may only be used with mappings created by
+-io_mapping_create_wc
++This _wc variant returns a write-combining map to the page and may only be
++used with mappings created by io_mapping_create_wc()
+ 
+-Note that the task may not sleep while holding this page
+-mapped.
++Temporary mappings are only valid in the context of the caller. The mapping
++is not guaranteed to be globaly visible.
+ 
+-::
++io_mapping_map_local_wc() has a side effect on X86 32bit as it disables
++migration to make the mapping code work. No caller can rely on this side
++effect.
+ 
+-	void io_mapping_unmap_atomic(void *vaddr)
++io_mapping_map_atomic_wc() has the side effect of disabling preemption and
++pagefaults. Don't use in new code. Use io_mapping_map_local_wc() instead.
+ 
+-'vaddr' must be the value returned by the last
+-io_mapping_map_atomic_wc call. This unmaps the specified
+-page and allows the task to sleep once again.
++Nested mappings need to be undone in reverse order because the mapping
++code uses a stack for keeping track of them::
+ 
+-If you need to sleep while holding the lock, you can use the non-atomic
+-variant, although they may be significantly slower.
++ addr1 = io_mapping_map_local_wc(map1, offset1);
++ addr2 = io_mapping_map_local_wc(map2, offset2);
++ ...
++ io_mapping_unmap_local(addr2);
++ io_mapping_unmap_local(addr1);
+ 
+-::
++The mappings are released with::
++
++	void io_mapping_unmap_local(void *vaddr)
++	void io_mapping_unmap_atomic(void *vaddr)
++
++'vaddr' must be the value returned by the last io_mapping_map_local_wc() or
++io_mapping_map_atomic_wc() call. This unmaps the specified mapping and
++undoes the side effects of the mapping functions.
++
++If you need to sleep while holding a mapping, you can use the regular
++variant, although this may be significantly slower::
+ 
+ 	void *io_mapping_map_wc(struct io_mapping *mapping,
+ 				unsigned long offset)
+ 
+-This works like io_mapping_map_atomic_wc except it allows
+-the task to sleep while holding the page mapped.
+-
++This works like io_mapping_map_atomic/local_wc() except it has no side
++effects and the pointer is globaly visible.
+ 
+-::
++The mappings are released with::
+ 
+ 	void io_mapping_unmap(void *vaddr)
+ 
+-This works like io_mapping_unmap_atomic, except it is used
+-for pages mapped with io_mapping_map_wc.
++Use for pages mapped with io_mapping_map_wc().
+ 
+ At driver close time, the io_mapping object must be freed::
+ 
+diff --git a/include/linux/io-mapping.h b/include/linux/io-mapping.h
+index 60e7c83e4904..c093e81310a9 100644
+--- a/include/linux/io-mapping.h
++++ b/include/linux/io-mapping.h
+@@ -82,6 +82,21 @@ io_mapping_unmap_atomic(void __iomem *vaddr)
+ 	preempt_enable();
+ }
+ 
++static inline void __iomem *
++io_mapping_map_local_wc(struct io_mapping *mapping, unsigned long offset)
++{
++	resource_size_t phys_addr;
++
++	BUG_ON(offset >= mapping->size);
++	phys_addr = mapping->base + offset;
++	return __iomap_local_pfn_prot(PHYS_PFN(phys_addr), mapping->prot);
++}
++
++static inline void io_mapping_unmap_local(void __iomem *vaddr)
++{
++	kunmap_local_indexed((void __force *)vaddr);
++}
++
+ static inline void __iomem *
+ io_mapping_map_wc(struct io_mapping *mapping,
+ 		  unsigned long offset,
+@@ -101,7 +116,7 @@ io_mapping_unmap(void __iomem *vaddr)
+ 	iounmap(vaddr);
+ }
+ 
+-#else
++#else  /* HAVE_ATOMIC_IOMAP */
+ 
+ #include <linux/uaccess.h>
+ 
+@@ -166,7 +181,18 @@ io_mapping_unmap_atomic(void __iomem *vaddr)
+ 	preempt_enable();
+ }
+ 
+-#endif /* HAVE_ATOMIC_IOMAP */
++static inline void __iomem *
++io_mapping_map_local_wc(struct io_mapping *mapping, unsigned long offset)
++{
++	return io_mapping_map_wc(mapping, offset, PAGE_SIZE);
++}
++
++static inline void io_mapping_unmap_local(void __iomem *vaddr)
++{
++	io_mapping_unmap(vaddr);
++}
++
++#endif /* !HAVE_ATOMIC_IOMAP */
+ 
+ static inline struct io_mapping *
+ io_mapping_create_wc(resource_size_t base,
+-- 
+2.43.0
+