Merge tag 'core-mm-2020-12-14' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip

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.

Nested mappings need to be undone in reverse order because the mapping

code uses a stack for keeping track of them::

'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.

 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)

If you need to sleep while holding the lock, you can use the non-atomic

variant, although they may be significantly slower.

'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::

	void io_mapping_free(struct io_mapping *mapping)

Current Implementation

======================

The initial implementation of these functions uses existing mapping

mechanisms and so provides only an abstraction layer and no new

functionality.

On 64-bit processors, io_mapping_create_wc calls ioremap_wc for the whole

range, creating a permanent kernel-visible mapping to the resource. The

map_atomic and map functions add the requested offset to the base of the

virtual address returned by ioremap_wc.

On 32-bit processors with HIGHMEM defined, io_mapping_map_atomic_wc uses

kmap_atomic_pfn to map the specified page in an atomic fashion;

kmap_atomic_pfn isn't really supposed to be used with device pages, but it

provides an efficient mapping for this usage.

On 32-bit processors without HIGHMEM defined, io_mapping_map_atomic_wc and

io_mapping_map_wc both use ioremap_wc, a terribly inefficient function which

performs an IPI to inform all processors about the new mapping. This results

in a significant performance penalty.

/* SPDX-License-Identifier: GPL-2.0 */

#ifndef _ASM_KMAP_TYPES_H

#define _ASM_KMAP_TYPES_H

/* Dummy header just to define km_type. */

#ifdef CONFIG_DEBUG_HIGHMEM

#define  __WITH_KM_FENCE

#endif

#include <asm-generic/kmap_types.h>

#undef __WITH_KM_FENCE

#endif

config HIGHMEM

	bool "High Memory Support"

	select ARCH_DISCONTIGMEM_ENABLE

	select KMAP_LOCAL

	help

	  With ARC 2G:2G address split, only upper 2G is directly addressable by

	  kernel. Enable this to potentially allow access to rest of 2G and PAE

#ifdef CONFIG_HIGHMEM

#include <uapi/asm/page.h>

#include <asm/kmap_types.h>

#include <asm/kmap_size.h>

#define FIXMAP_SIZE		PGDIR_SIZE

#define PKMAP_SIZE		PGDIR_SIZE

/* start after vmalloc area */

#define FIXMAP_BASE		(PAGE_OFFSET - FIXMAP_SIZE - PKMAP_SIZE)

#define FIXMAP_SIZE		PGDIR_SIZE	/* only 1 PGD worth */

#define KM_TYPE_NR		((FIXMAP_SIZE >> PAGE_SHIFT)/NR_CPUS)

#define FIXMAP_ADDR(nr)		(FIXMAP_BASE + ((nr) << PAGE_SHIFT))

#define FIX_KMAP_SLOTS		(KM_MAX_IDX * NR_CPUS)

#define FIX_KMAP_BEGIN		(0UL)

#define FIX_KMAP_END		((FIX_KMAP_BEGIN + FIX_KMAP_SLOTS) - 1)

#define FIXADDR_TOP		(FIXMAP_BASE + (FIX_KMAP_END << PAGE_SHIFT))

/*

 * This should be converted to the asm-generic version, but of course this

 * is needlessly different from all other architectures. Sigh - tglx

 */

#define __fix_to_virt(x)	(FIXADDR_TOP - ((x) << PAGE_SHIFT))

#define __virt_to_fix(x)	(((FIXADDR_TOP - ((x) & PAGE_MASK))) >> PAGE_SHIFT)

/* start after fixmap area */

#define PKMAP_BASE		(FIXMAP_BASE + FIXMAP_SIZE)

#define PKMAP_SIZE		PGDIR_SIZE

#define LAST_PKMAP		(PKMAP_SIZE >> PAGE_SHIFT)

#define LAST_PKMAP_MASK		(LAST_PKMAP - 1)

#define PKMAP_ADDR(nr)		(PKMAP_BASE + ((nr) << PAGE_SHIFT))

extern void kmap_init(void);

#define arch_kmap_local_post_unmap(vaddr)			\

	local_flush_tlb_kernel_range(vaddr, vaddr + PAGE_SIZE)

static inline void flush_cache_kmaps(void)

{

	flush_cache_all();

}

#endif

#endif

/* SPDX-License-Identifier: GPL-2.0-only */

/*

 * Copyright (C) 2015 Synopsys, Inc. (www.synopsys.com)

 */

#ifndef _ASM_KMAP_TYPES_H

#define _ASM_KMAP_TYPES_H

/*

 * We primarily need to define KM_TYPE_NR here but that in turn

 * is a function of PGDIR_SIZE etc.

 * To avoid circular deps issue, put everything in asm/highmem.h

 */

#endif