[GitHub/mt8127/android_kernel_alcatel_ttab.git] / arch / mn10300 / mm / cache-smp-inv.c

/* Functions for global i/dcache invalidation when caching in SMP
 *
 * Copyright (C) 2010 Red Hat, Inc. All Rights Reserved.
 * Written by David Howells (dhowells@redhat.com)
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public Licence
 * as published by the Free Software Foundation; either version
 * 2 of the Licence, or (at your option) any later version.
 */
#include <linux/mm.h>
#include <asm/cacheflush.h>
#include "cache-smp.h"

/**
 * mn10300_icache_inv - Globally invalidate instruction cache
 *
 * Invalidate the instruction cache on all CPUs.
 */
void mn10300_icache_inv(void)
{
	unsigned long flags;

	flags = smp_lock_cache();
	mn10300_local_icache_inv();
	smp_cache_call(SMP_ICACHE_INV, 0, 0);
	smp_unlock_cache(flags);
}

/**
 * mn10300_icache_inv_page - Globally invalidate a page of instruction cache
 * @start: The address of the page of memory to be invalidated.
 *
 * Invalidate a range of addresses in the instruction cache on all CPUs
 * covering the page that includes the given address.
 */
void mn10300_icache_inv_page(unsigned long start)
{
	unsigned long flags;

	start &= ~(PAGE_SIZE-1);

	flags = smp_lock_cache();
	mn10300_local_icache_inv_page(start);
	smp_cache_call(SMP_ICACHE_INV_RANGE, start, start + PAGE_SIZE);
	smp_unlock_cache(flags);
}

/**
 * mn10300_icache_inv_range - Globally invalidate range of instruction cache
 * @start: The start address of the region to be invalidated.
 * @end: The end address of the region to be invalidated.
 *
 * Invalidate a range of addresses in the instruction cache on all CPUs,
 * between start and end-1 inclusive.
 */
void mn10300_icache_inv_range(unsigned long start, unsigned long end)
{
	unsigned long flags;

	flags = smp_lock_cache();
	mn10300_local_icache_inv_range(start, end);
	smp_cache_call(SMP_ICACHE_INV_RANGE, start, end);
	smp_unlock_cache(flags);
}

/**
 * mn10300_icache_inv_range2 - Globally invalidate range of instruction cache
 * @start: The start address of the region to be invalidated.
 * @size: The size of the region to be invalidated.
 *
 * Invalidate a range of addresses in the instruction cache on all CPUs,
 * between start and start+size-1 inclusive.
 */
void mn10300_icache_inv_range2(unsigned long start, unsigned long size)
{
	unsigned long flags;

	flags = smp_lock_cache();
	mn10300_local_icache_inv_range2(start, size);
	smp_cache_call(SMP_ICACHE_INV_RANGE, start, start + size);
	smp_unlock_cache(flags);
}

/**
 * mn10300_dcache_inv - Globally invalidate data cache
 *
 * Invalidate the data cache on all CPUs.
 */
void mn10300_dcache_inv(void)
{
	unsigned long flags;

	flags = smp_lock_cache();
	mn10300_local_dcache_inv();
	smp_cache_call(SMP_DCACHE_INV, 0, 0);
	smp_unlock_cache(flags);
}

/**
 * mn10300_dcache_inv_page - Globally invalidate a page of data cache
 * @start: The address of the page of memory to be invalidated.
 *
 * Invalidate a range of addresses in the data cache on all CPUs covering the
 * page that includes the given address.
 */
void mn10300_dcache_inv_page(unsigned long start)
{
	unsigned long flags;

	start &= ~(PAGE_SIZE-1);

	flags = smp_lock_cache();
	mn10300_local_dcache_inv_page(start);
	smp_cache_call(SMP_DCACHE_INV_RANGE, start, start + PAGE_SIZE);
	smp_unlock_cache(flags);
}

/**
 * mn10300_dcache_inv_range - Globally invalidate range of data cache
 * @start: The start address of the region to be invalidated.
 * @end: The end address of the region to be invalidated.
 *
 * Invalidate a range of addresses in the data cache on all CPUs, between start
 * and end-1 inclusive.
 */
void mn10300_dcache_inv_range(unsigned long start, unsigned long end)
{
	unsigned long flags;

	flags = smp_lock_cache();
	mn10300_local_dcache_inv_range(start, end);
	smp_cache_call(SMP_DCACHE_INV_RANGE, start, end);
	smp_unlock_cache(flags);
}

/**
 * mn10300_dcache_inv_range2 - Globally invalidate range of data cache
 * @start: The start address of the region to be invalidated.
 * @size: The size of the region to be invalidated.
 *
 * Invalidate a range of addresses in the data cache on all CPUs, between start
 * and start+size-1 inclusive.
 */
void mn10300_dcache_inv_range2(unsigned long start, unsigned long size)
{
	unsigned long flags;

	flags = smp_lock_cache();
	mn10300_local_dcache_inv_range2(start, size);
	smp_cache_call(SMP_DCACHE_INV_RANGE, start, start + size);
	smp_unlock_cache(flags);
}
Commit	Line	Data
8be06289 AT	1	/* Functions for global i/dcache invalidation when caching in SMP
	2	*
	3	* Copyright (C) 2010 Red Hat, Inc. All Rights Reserved.
	4	* Written by David Howells (dhowells@redhat.com)
	5	*
	6	* This program is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU General Public Licence
	8	* as published by the Free Software Foundation; either version
	9	* 2 of the Licence, or (at your option) any later version.
	10	*/
	11	#include <linux/mm.h>
	12	#include <asm/cacheflush.h>
	13	#include "cache-smp.h"
	14
	15	/**
	16	* mn10300_icache_inv - Globally invalidate instruction cache
	17	*
	18	* Invalidate the instruction cache on all CPUs.
	19	*/
	20	void mn10300_icache_inv(void)
	21	{
	22	unsigned long flags;
	23
	24	flags = smp_lock_cache();
	25	mn10300_local_icache_inv();
	26	smp_cache_call(SMP_ICACHE_INV, 0, 0);
	27	smp_unlock_cache(flags);
	28	}
	29
	30	/**
	31	* mn10300_icache_inv_page - Globally invalidate a page of instruction cache
	32	* @start: The address of the page of memory to be invalidated.
	33	*
	34	* Invalidate a range of addresses in the instruction cache on all CPUs
	35	* covering the page that includes the given address.
	36	*/
	37	void mn10300_icache_inv_page(unsigned long start)
	38	{
	39	unsigned long flags;
	40
	41	start &= ~(PAGE_SIZE-1);
	42
	43	flags = smp_lock_cache();
	44	mn10300_local_icache_inv_page(start);
	45	smp_cache_call(SMP_ICACHE_INV_RANGE, start, start + PAGE_SIZE);
	46	smp_unlock_cache(flags);
	47	}
	48
	49	/**
	50	* mn10300_icache_inv_range - Globally invalidate range of instruction cache
	51	* @start: The start address of the region to be invalidated.
	52	* @end: The end address of the region to be invalidated.
	53	*
	54	* Invalidate a range of addresses in the instruction cache on all CPUs,
	55	* between start and end-1 inclusive.
	56	*/
	57	void mn10300_icache_inv_range(unsigned long start, unsigned long end)
	58	{
	59	unsigned long flags;
	60
	61	flags = smp_lock_cache();
	62	mn10300_local_icache_inv_range(start, end);
	63	smp_cache_call(SMP_ICACHE_INV_RANGE, start, end);
	64	smp_unlock_cache(flags);
65	}
66
67	/**
68	* mn10300_icache_inv_range2 - Globally invalidate range of instruction cache
69	* @start: The start address of the region to be invalidated.
70	* @size: The size of the region to be invalidated.
71	*
72	* Invalidate a range of addresses in the instruction cache on all CPUs,
73	* between start and start+size-1 inclusive.
74	*/
75	void mn10300_icache_inv_range2(unsigned long start, unsigned long size)
76	{
77	unsigned long flags;
78
79	flags = smp_lock_cache();
80	mn10300_local_icache_inv_range2(start, size);
81	smp_cache_call(SMP_ICACHE_INV_RANGE, start, start + size);
82	smp_unlock_cache(flags);
83	}
84
85	/**
86	* mn10300_dcache_inv - Globally invalidate data cache
87	*
88	* Invalidate the data cache on all CPUs.
89	*/
90	void mn10300_dcache_inv(void)
91	{
92	unsigned long flags;
93
94	flags = smp_lock_cache();
95	mn10300_local_dcache_inv();
96	smp_cache_call(SMP_DCACHE_INV, 0, 0);
97	smp_unlock_cache(flags);
98	}
99
100	/**
101	* mn10300_dcache_inv_page - Globally invalidate a page of data cache
102	* @start: The address of the page of memory to be invalidated.
103	*
104	* Invalidate a range of addresses in the data cache on all CPUs covering the
105	* page that includes the given address.
106	*/
107	void mn10300_dcache_inv_page(unsigned long start)
108	{
109	unsigned long flags;
110
111	start &= ~(PAGE_SIZE-1);
112
113	flags = smp_lock_cache();
114	mn10300_local_dcache_inv_page(start);
115	smp_cache_call(SMP_DCACHE_INV_RANGE, start, start + PAGE_SIZE);
116	smp_unlock_cache(flags);
117	}
118
119	/**
120	* mn10300_dcache_inv_range - Globally invalidate range of data cache
121	* @start: The start address of the region to be invalidated.
122	* @end: The end address of the region to be invalidated.
123	*
124	* Invalidate a range of addresses in the data cache on all CPUs, between start
125	* and end-1 inclusive.
126	*/
127	void mn10300_dcache_inv_range(unsigned long start, unsigned long end)
128	{
129	unsigned long flags;
130
131	flags = smp_lock_cache();
132	mn10300_local_dcache_inv_range(start, end);
133	smp_cache_call(SMP_DCACHE_INV_RANGE, start, end);
134	smp_unlock_cache(flags);
135	}
136
137	/**
138	* mn10300_dcache_inv_range2 - Globally invalidate range of data cache
139	* @start: The start address of the region to be invalidated.
140	* @size: The size of the region to be invalidated.
141	*
142	* Invalidate a range of addresses in the data cache on all CPUs, between start
143	* and start+size-1 inclusive.
144	*/
145	void mn10300_dcache_inv_range2(unsigned long start, unsigned long size)
146	{
147	unsigned long flags;
148
149	flags = smp_lock_cache();
150	mn10300_local_dcache_inv_range2(start, size);
151	smp_cache_call(SMP_DCACHE_INV_RANGE, start, start + size);
152	smp_unlock_cache(flags);
153	}