LXR linux/arch/mn10300/mm/cache-smp-flush.c

   1/* Functions for global dcache flush when writeback 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_dcache_flush - Globally flush data cache
  17 *
  18 * Flush the data cache on all CPUs.
  19 */
  20void mn10300_dcache_flush(void)
  21{
  22        unsigned long flags;
  23
  24        flags = smp_lock_cache();
  25        mn10300_local_dcache_flush();
  26        smp_cache_call(SMP_DCACHE_FLUSH, 0, 0);
  27        smp_unlock_cache(flags);
  28}
  29
  30/**
  31 * mn10300_dcache_flush_page - Globally flush a page of data cache
  32 * @start: The address of the page of memory to be flushed.
  33 *
  34 * Flush a range of addresses in the data cache on all CPUs covering
  35 * the page that includes the given address.
  36 */
  37void mn10300_dcache_flush_page(unsigned long start)
  38{
  39        unsigned long flags;
  40
  41        start &= ~(PAGE_SIZE-1);
  42
  43        flags = smp_lock_cache();
  44        mn10300_local_dcache_flush_page(start);
  45        smp_cache_call(SMP_DCACHE_FLUSH_RANGE, start, start + PAGE_SIZE);
  46        smp_unlock_cache(flags);
  47}
  48
  49/**
  50 * mn10300_dcache_flush_range - Globally flush range of data cache
  51 * @start: The start address of the region to be flushed.
  52 * @end: The end address of the region to be flushed.
  53 *
  54 * Flush a range of addresses in the data cache on all CPUs, between start and
  55 * end-1 inclusive.
  56 */
  57void mn10300_dcache_flush_range(unsigned long start, unsigned long end)
  58{
  59        unsigned long flags;
  60
  61        flags = smp_lock_cache();
  62        mn10300_local_dcache_flush_range(start, end);
  63        smp_cache_call(SMP_DCACHE_FLUSH_RANGE, start, end);
  64        smp_unlock_cache(flags);
  65}
  66
  67/**
  68 * mn10300_dcache_flush_range2 - Globally flush range of data cache
  69 * @start: The start address of the region to be flushed.
  70 * @size: The size of the region to be flushed.
  71 *
  72 * Flush a range of addresses in the data cache on all CPUs, between start and
  73 * start+size-1 inclusive.
  74 */
  75void mn10300_dcache_flush_range2(unsigned long start, unsigned long size)
  76{
  77        unsigned long flags;
  78
  79        flags = smp_lock_cache();
  80        mn10300_local_dcache_flush_range2(start, size);
  81        smp_cache_call(SMP_DCACHE_FLUSH_RANGE, start, start + size);
  82        smp_unlock_cache(flags);
  83}
  84
  85/**
  86 * mn10300_dcache_flush_inv - Globally flush and invalidate data cache
  87 *
  88 * Flush and invalidate the data cache on all CPUs.
  89 */
  90void mn10300_dcache_flush_inv(void)
  91{
  92        unsigned long flags;
  93
  94        flags = smp_lock_cache();
  95        mn10300_local_dcache_flush_inv();
  96        smp_cache_call(SMP_DCACHE_FLUSH_INV, 0, 0);
  97        smp_unlock_cache(flags);
  98}
  99
 100/**
 101 * mn10300_dcache_flush_inv_page - Globally flush and invalidate a page of data
 102 *      cache
 103 * @start: The address of the page of memory to be flushed and invalidated.
 104 *
 105 * Flush and invalidate a range of addresses in the data cache on all CPUs
 106 * covering the page that includes the given address.
 107 */
 108void mn10300_dcache_flush_inv_page(unsigned long start)
 109{
 110        unsigned long flags;
 111
 112        start &= ~(PAGE_SIZE-1);
 113
 114        flags = smp_lock_cache();
 115        mn10300_local_dcache_flush_inv_page(start);
 116        smp_cache_call(SMP_DCACHE_FLUSH_INV_RANGE, start, start + PAGE_SIZE);
 117        smp_unlock_cache(flags);
 118}
 119
 120/**
 121 * mn10300_dcache_flush_inv_range - Globally flush and invalidate range of data
 122 *      cache
 123 * @start: The start address of the region to be flushed and invalidated.
 124 * @end: The end address of the region to be flushed and invalidated.
 125 *
 126 * Flush and invalidate a range of addresses in the data cache on all CPUs,
 127 * between start and end-1 inclusive.
 128 */
 129void mn10300_dcache_flush_inv_range(unsigned long start, unsigned long end)
 130{
 131        unsigned long flags;
 132
 133        flags = smp_lock_cache();
 134        mn10300_local_dcache_flush_inv_range(start, end);
 135        smp_cache_call(SMP_DCACHE_FLUSH_INV_RANGE, start, end);
 136        smp_unlock_cache(flags);
 137}
 138
 139/**
 140 * mn10300_dcache_flush_inv_range2 - Globally flush and invalidate range of data
 141 *      cache
 142 * @start: The start address of the region to be flushed and invalidated.
 143 * @size: The size of the region to be flushed and invalidated.
 144 *
 145 * Flush and invalidate a range of addresses in the data cache on all CPUs,
 146 * between start and start+size-1 inclusive.
 147 */
 148void mn10300_dcache_flush_inv_range2(unsigned long start, unsigned long size)
 149{
 150        unsigned long flags;
 151
 152        flags = smp_lock_cache();
 153        mn10300_local_dcache_flush_inv_range2(start, size);
 154        smp_cache_call(SMP_DCACHE_FLUSH_INV_RANGE, start, start + size);
 155        smp_unlock_cache(flags);
 156}
 157