include/asm-blackfin/mmu_context.h

   1 /*
   2  * File:         include/asm-blackfin/mmu_context.h
   3  * Based on:
   4  * Author:
   5  *
   6  * Created:
   7  * Description:
   8  *
   9  * Modified:
  10  *               Copyright 2004-2006 Analog Devices Inc.
  11  *
  12  * Bugs:         Enter bugs at http://blackfin.uclinux.org/
  13  *
  14  * This program is free software; you can redistribute it and/or modify
  15  * it under the terms of the GNU General Public License as published by
  16  * the Free Software Foundation; either version 2 of the License, or
  17  * (at your option) any later version.
  18  *
  19  * This program is distributed in the hope that it will be useful,
  20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  * GNU General Public License for more details.
  23  *
  24  * You should have received a copy of the GNU General Public License
  25  * along with this program; if not, see the file COPYING, or write
  26  * to the Free Software Foundation, Inc.,
  27  * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  28  */
  29
  30 #ifndef __BLACKFIN_MMU_CONTEXT_H__
  31 #define __BLACKFIN_MMU_CONTEXT_H__
  32
  33 #include <asm/setup.h>
  34 #include <asm/page.h>
  35 #include <asm/pgalloc.h>
  36
  37 extern void *current_l1_stack_save;
  38 extern int nr_l1stack_tasks;
  39 extern void *l1_stack_base;
  40 extern unsigned long l1_stack_len;
  41
  42 extern int l1sram_free(const void*);
  43 extern void *l1sram_alloc_max(void*);
  44
  45 static inline void enter_lazy_tlb(struct mm_struct *mm, struct task_struct *tsk)
  46 {
  47 }
  48
  49 /* Called when creating a new context during fork() or execve().  */
  50 static inline int
  51 init_new_context(struct task_struct *tsk, struct mm_struct *mm)
  52 {
  53         return 0;
  54 }
  55
  56 static inline void free_l1stack(void)
  57 {
  58         nr_l1stack_tasks--;
  59         if (nr_l1stack_tasks == 0)
  60                 l1sram_free(l1_stack_base);
  61 }
  62 static inline void destroy_context(struct mm_struct *mm)
  63 {
  64         struct sram_list_struct *tmp;
  65
  66         if (current_l1_stack_save == mm->context.l1_stack_save)
  67                 current_l1_stack_save = 0;
  68         if (mm->context.l1_stack_save)
  69                 free_l1stack();
  70
  71         while ((tmp = mm->context.sram_list)) {
  72                 mm->context.sram_list = tmp->next;
  73                 sram_free(tmp->addr);
  74                 kfree(tmp);
  75         }
  76 }
  77
  78 static inline unsigned long
  79 alloc_l1stack(unsigned long length, unsigned long *stack_base)
  80 {
  81         if (nr_l1stack_tasks == 0) {
  82                 l1_stack_base = l1sram_alloc_max(&l1_stack_len);
  83                 if (!l1_stack_base)
  84                         return 0;
  85         }
  86
  87         if (l1_stack_len < length) {
  88                 if (nr_l1stack_tasks == 0)
  89                         l1sram_free(l1_stack_base);
  90                 return 0;
  91         }
  92         *stack_base = (unsigned long)l1_stack_base;
  93         nr_l1stack_tasks++;
  94         return l1_stack_len;
  95 }
  96
  97 static inline int
  98 activate_l1stack(struct mm_struct *mm, unsigned long sp_base)
  99 {
 100         if (current_l1_stack_save)
 101                 memcpy(current_l1_stack_save, l1_stack_base, l1_stack_len);
 102         mm->context.l1_stack_save = current_l1_stack_save = (void*)sp_base;
 103         memcpy(l1_stack_base, current_l1_stack_save, l1_stack_len);
 104         return 1;
 105 }
 106
 107 #define deactivate_mm(tsk,mm)   do { } while (0)
 108
 109 static inline void activate_mm(struct mm_struct *prev_mm,
 110                                struct mm_struct *next_mm)
 111 {
 112         if (!next_mm->context.l1_stack_save)
 113                 return;
 114         if (next_mm->context.l1_stack_save == current_l1_stack_save)
 115                 return;
 116         if (current_l1_stack_save) {
 117                 memcpy(current_l1_stack_save, l1_stack_base, l1_stack_len);
 118         }
 119         current_l1_stack_save = next_mm->context.l1_stack_save;
 120         memcpy(l1_stack_base, current_l1_stack_save, l1_stack_len);
 121 }
 122
 123 static inline void switch_mm(struct mm_struct *prev, struct mm_struct *next,
 124                              struct task_struct *tsk)
 125 {
 126         activate_mm(prev, next);
 127 }
 128
 129 #endif