arch/hexagon/mm/cache.c

   1 /*
   2  * Cache management functions for Hexagon
   3  *
   4  * Copyright (c) 2010-2011, The Linux Foundation. All rights reserved.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 and
   8  * only version 2 as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  18  * 02110-1301, USA.
  19  */
  20
  21 #include <linux/mm.h>
  22 #include <asm/cacheflush.h>
  23 #include <asm/hexagon_vm.h>
  24
  25 #define spanlines(start, end) \
  26         (((end - (start & ~(LINESIZE - 1))) >> LINEBITS) + 1)
  27
  28 void flush_dcache_range(unsigned long start, unsigned long end)
  29 {
  30         unsigned long lines = spanlines(start, end-1);
  31         unsigned long i, flags;
  32
  33         start &= ~(LINESIZE - 1);
  34
  35         local_irq_save(flags);
  36
  37         for (i = 0; i < lines; i++) {
  38                 __asm__ __volatile__ (
  39                 "       dccleaninva(%0);        "
  40                 :
  41                 : "r" (start)
  42                 );
  43                 start += LINESIZE;
  44         }
  45         local_irq_restore(flags);
  46 }
  47
  48 void flush_icache_range(unsigned long start, unsigned long end)
  49 {
  50         unsigned long lines = spanlines(start, end-1);
  51         unsigned long i, flags;
  52
  53         start &= ~(LINESIZE - 1);
  54
  55         local_irq_save(flags);
  56
  57         for (i = 0; i < lines; i++) {
  58                 __asm__ __volatile__ (
  59                         "       dccleana(%0); "
  60                         "       icinva(%0);     "
  61                         :
  62                         : "r" (start)
  63                 );
  64                 start += LINESIZE;
  65         }
  66         __asm__ __volatile__ (
  67                 "isync"
  68         );
  69         local_irq_restore(flags);
  70 }
  71 EXPORT_SYMBOL(flush_icache_range);
  72
  73 void hexagon_clean_dcache_range(unsigned long start, unsigned long end)
  74 {
  75         unsigned long lines = spanlines(start, end-1);
  76         unsigned long i, flags;
  77
  78         start &= ~(LINESIZE - 1);
  79
  80         local_irq_save(flags);
  81
  82         for (i = 0; i < lines; i++) {
  83                 __asm__ __volatile__ (
  84                 "       dccleana(%0);   "
  85                 :
  86                 : "r" (start)
  87                 );
  88                 start += LINESIZE;
  89         }
  90         local_irq_restore(flags);
  91 }
  92
  93 void hexagon_inv_dcache_range(unsigned long start, unsigned long end)
  94 {
  95         unsigned long lines = spanlines(start, end-1);
  96         unsigned long i, flags;
  97
  98         start &= ~(LINESIZE - 1);
  99
 100         local_irq_save(flags);
 101
 102         for (i = 0; i < lines; i++) {
 103                 __asm__ __volatile__ (
 104                 "       dcinva(%0);     "
 105                 :
 106                 : "r" (start)
 107                 );
 108                 start += LINESIZE;
 109         }
 110         local_irq_restore(flags);
 111 }
 112
 113
 114
 115
 116 /*
 117  * This is just really brutal and shouldn't be used anyways,
 118  * especially on V2.  Left here just in case.
 119  */
 120 void flush_cache_all_hexagon(void)
 121 {
 122         unsigned long flags;
 123         local_irq_save(flags);
 124         __vmcache_ickill();
 125         __vmcache_dckill();
 126         __vmcache_l2kill();
 127         local_irq_restore(flags);
 128         mb();
 129 }
 130
 131 void copy_to_user_page(struct vm_area_struct *vma, struct page *page,
 132                        unsigned long vaddr, void *dst, void *src, int len)
 133 {
 134         memcpy(dst, src, len);
 135         if (vma->vm_flags & VM_EXEC) {
 136                 flush_icache_range((unsigned long) dst,
 137                 (unsigned long) dst + len);
 138         }
 139 }