Eric Lee / linux-smarc-t335x-v3.2

Commit 9663f2e6a6cf3f82b06d8fb699b11b80f92553ba

Authored by Keith Packard 2008-10-31 10:38:18 +0800

Committed by Ingo Molnar 2008-10-31 17:12:39 +0800

Exists in master and in 4 other branches

resources: add io-mapping functions to dynamically map large device apertures

Impact: add new generic io_map_*() APIs

Graphics devices have large PCI apertures which would consume a significant
fraction of a 32-bit address space if mapped during driver initialization.
Using ioremap at runtime is impractical as it is too slow.

This new set of interfaces uses atomic mappings on 32-bit processors and a
large static mapping on 64-bit processors to provide reasonable 32-bit
performance and optimal 64-bit performance.

The current implementation sits atop the io_map_atomic fixmap-based
mechanism for 32-bit processors.

This includes some editorial suggestions from Randy Dunlap for
Documentation/io-mapping.txt

Signed-off-by: Keith Packard <keithp@keithp.com>
Signed-off-by: Eric Anholt <eric@anholt.net>
Signed-off-by: Ingo Molnar <mingo@elte.hu>

Showing 2 changed files with 194 additions and 0 deletions Side-by-side Diff

Documentation/io-mapping.txt
include/linux/io-mapping.h

Documentation/io-mapping.txt

Diff comments View file @ 9663f2e

	1	+The io_mapping functions in linux/io-mapping.h provide an abstraction for
	2	+efficiently mapping small regions of an I/O device to the CPU. The initial
	3	+usage is to support the large graphics aperture on 32-bit processors where
	4	+ioremap_wc cannot be used to statically map the entire aperture to the CPU
	5	+as it would consume too much of the kernel address space.
	6	+
	7	+A mapping object is created during driver initialization using
	8	+
	9	+ struct io_mapping *io_mapping_create_wc(unsigned long base,
	10	+ unsigned long size)
	11	+
	12	+ 'base' is the bus address of the region to be made
	13	+ mappable, while 'size' indicates how large a mapping region to
	14	+ enable. Both are in bytes.
	15	+
	16	+ This _wc variant provides a mapping which may only be used
	17	+ with the io_mapping_map_atomic_wc or io_mapping_map_wc.
	18	+
	19	+With this mapping object, individual pages can be mapped either atomically
	20	+or not, depending on the necessary scheduling environment. Of course, atomic
	21	+maps are more efficient:
	22	+
	23	+ void io_mapping_map_atomic_wc(struct io_mapping mapping,
	24	+ unsigned long offset)
	25	+
	26	+ 'offset' is the offset within the defined mapping region.
	27	+ Accessing addresses beyond the region specified in the
	28	+ creation function yields undefined results. Using an offset
	29	+ which is not page aligned yields an undefined result. The
	30	+ return value points to a single page in CPU address space.
	31	+
	32	+ This _wc variant returns a write-combining map to the
	33	+ page and may only be used with mappings created by
	34	+ io_mapping_create_wc
	35	+
	36	+ Note that the task may not sleep while holding this page
	37	+ mapped.
	38	+
	39	+ void io_mapping_unmap_atomic(void *vaddr)
	40	+
	41	+ 'vaddr' must be the the value returned by the last
	42	+ io_mapping_map_atomic_wc call. This unmaps the specified
	43	+ page and allows the task to sleep once again.
	44	+
	45	+If you need to sleep while holding the lock, you can use the non-atomic
	46	+variant, although they may be significantly slower.
	47	+
	48	+ void io_mapping_map_wc(struct io_mapping mapping,
	49	+ unsigned long offset)
	50	+
	51	+ This works like io_mapping_map_atomic_wc except it allows
	52	+ the task to sleep while holding the page mapped.
	53	+
	54	+ void io_mapping_unmap(void *vaddr)
	55	+
	56	+ This works like io_mapping_unmap_atomic, except it is used
	57	+ for pages mapped with io_mapping_map_wc.
	58	+
	59	+At driver close time, the io_mapping object must be freed:
	60	+
	61	+ void io_mapping_free(struct io_mapping *mapping)
	62	+
	63	+Current Implementation:
	64	+
	65	+The initial implementation of these functions uses existing mapping
	66	+mechanisms and so provides only an abstraction layer and no new
	67	+functionality.
	68	+
	69	+On 64-bit processors, io_mapping_create_wc calls ioremap_wc for the whole
	70	+range, creating a permanent kernel-visible mapping to the resource. The
	71	+map_atomic and map functions add the requested offset to the base of the
	72	+virtual address returned by ioremap_wc.
	73	+
	74	+On 32-bit processors, io_mapping_map_atomic_wc uses io_map_atomic_prot_pfn,
	75	+which uses the fixmaps to get us a mapping to a page using an atomic fashion.
	76	+For io_mapping_map_wc, ioremap_wc() is used to get a mapping of the region.

include/linux/io-mapping.h

Diff comments View file @ 9663f2e

	1	+/*
	2	+ * Copyright © 2008 Keith Packard <keithp@keithp.com>
	3	+ *
	4	+ * This file is free software; you can redistribute it and/or modify
	5	+ * it under the terms of version 2 of the GNU General Public License
	6	+ * as published by the Free Software Foundation.
	7	+ *
	8	+ * This program is distributed in the hope that it will be useful,
	9	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
	10	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	11	+ * GNU General Public License for more details.
	12	+ *
	13	+ * You should have received a copy of the GNU General Public License
	14	+ * along with this program; if not, write to the Free Software Foundation,
	15	+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
	16	+ */
	17	+
	18	+#ifndef _LINUX_IO_MAPPING_H
	19	+#define _LINUX_IO_MAPPING_H
	20	+
	21	+#include <linux/types.h>
	22	+#include <asm/io.h>
	23	+#include <asm/page.h>
	24	+#include <asm/iomap.h>
	25	+
	26	+/*
	27	+ * The io_mapping mechanism provides an abstraction for mapping
	28	+ * individual pages from an io device to the CPU in an efficient fashion.
	29	+ *
	30	+ * See Documentation/io_mapping.txt
	31	+ */
	32	+
	33	+/* this struct isn't actually defined anywhere */
	34	+struct io_mapping;
	35	+
	36	+#ifdef CONFIG_X86_64
	37	+
	38	+/* Create the io_mapping object*/
	39	+static inline struct io_mapping *
	40	+io_mapping_create_wc(unsigned long base, unsigned long size)
	41	+{
	42	+ return (struct io_mapping *) ioremap_wc(base, size);
	43	+}
	44	+
	45	+static inline void
	46	+io_mapping_free(struct io_mapping *mapping)
	47	+{
	48	+ iounmap(mapping);
	49	+}
	50	+
	51	+/* Atomic map/unmap */
	52	+static inline void *
	53	+io_mapping_map_atomic_wc(struct io_mapping *mapping, unsigned long offset)
	54	+{
	55	+ return ((char *) mapping) + offset;
	56	+}
	57	+
	58	+static inline void
	59	+io_mapping_unmap_atomic(void *vaddr)
	60	+{
	61	+}
	62	+
	63	+/* Non-atomic map/unmap */
	64	+static inline void *
	65	+io_mapping_map_wc(struct io_mapping *mapping, unsigned long offset)
	66	+{
	67	+ return ((char *) mapping) + offset;
	68	+}
	69	+
	70	+static inline void
	71	+io_mapping_unmap(void *vaddr)
	72	+{
	73	+}
	74	+
	75	+#endif /* CONFIG_X86_64 */
	76	+
	77	+#ifdef CONFIG_X86_32
	78	+static inline struct io_mapping *
	79	+io_mapping_create_wc(unsigned long base, unsigned long size)
	80	+{
	81	+ return (struct io_mapping *) base;
	82	+}
	83	+
	84	+static inline void
	85	+io_mapping_free(struct io_mapping *mapping)
	86	+{
	87	+}
	88	+
	89	+/* Atomic map/unmap */
	90	+static inline void *
	91	+io_mapping_map_atomic_wc(struct io_mapping *mapping, unsigned long offset)
	92	+{
	93	+ offset += (unsigned long) mapping;
	94	+ return iomap_atomic_prot_pfn(offset >> PAGE_SHIFT, KM_USER0,
	95	+ __pgprot(__PAGE_KERNEL_WC));
	96	+}
	97	+
	98	+static inline void
	99	+io_mapping_unmap_atomic(void *vaddr)
	100	+{
	101	+ iounmap_atomic(vaddr, KM_USER0);
	102	+}
	103	+
	104	+static inline void *
	105	+io_mapping_map_wc(struct io_mapping *mapping, unsigned long offset)
	106	+{
	107	+ offset += (unsigned long) mapping;
	108	+ return ioremap_wc(offset, PAGE_SIZE);
	109	+}
	110	+
	111	+static inline void
	112	+io_mapping_unmap(void *vaddr)
	113	+{
	114	+ iounmap(vaddr);
	115	+}
	116	+#endif /* CONFIG_X86_32 */
	117	+
	118	+#endif /* _LINUX_IO_MAPPING_H */