Subversion Repositories or1k

/* sun3_pgalloc.h --

 * reorganization around 2.3.39, routines moved from sun3_pgtable.h

 *

 * moved 1/26/2000 Sam Creasey

 */

#ifndef _SUN3_PGALLOC_H

#define _SUN3_PGALLOC_H

/* Pagetable caches. */

//todo: should implement for at least ptes. --m

#define pgd_quicklist ((unsigned long *) 0)

#define pmd_quicklist ((unsigned long *) 0)

#define pte_quicklist ((unsigned long *) 0)

#define pgtable_cache_size (0L)

/* Allocation and deallocation of various flavours of pagetables. */

static inline int free_pmd_fast(pmd_t *pmdp) { return 0; }

static inline int free_pmd_slow(pmd_t *pmdp) { return 0; }

static inline pmd_t *get_pmd_fast (void) { return (pmd_t *) 0; }

//todo: implement the following properly.

#define get_pte_fast() ((pte_t *) 0)

#define get_pte_slow pte_alloc

#define free_pte_fast(pte)

#define free_pte_slow pte_free

/* FIXME - when we get this compiling */

/* erm, now that it's compiling, what do we do with it? */

#define _KERNPG_TABLE 0

static inline void pte_free_kernel(pte_t *pte)

{

        free_page((unsigned long) pte);

}

extern const char bad_pmd_string[];

static inline pte_t *pte_alloc_kernel(pmd_t *pmd, unsigned long address)

{

        address = (address >> PAGE_SHIFT) & (PTRS_PER_PTE - 1);

        if (pmd_none(*pmd)) {

                pte_t * page = (pte_t *) get_free_page(GFP_KERNEL);

                if (pmd_none(*pmd)) {

                        if (page) {

                                pmd_val(*pmd) = _KERNPG_TABLE + __pa(page);

                                return page + address;

                        }

                        pmd_val(*pmd) = _KERNPG_TABLE + __pa((unsigned long)BAD_PAGETABLE);

                        return NULL;

                }

                free_page((unsigned long) page);

        }

        if (pmd_bad(*pmd)) {

                printk(bad_pmd_string, pmd_val(*pmd));

                printk("at kernel pgd off %08x\n", (unsigned int)pmd);

                pmd_val(*pmd) = _KERNPG_TABLE + __pa((unsigned long)BAD_PAGETABLE);

                return NULL;

        }

        return (pte_t *) __pmd_page(*pmd) + address;

}

/*

 * allocating and freeing a pmd is trivial: the 1-entry pmd is

 * inside the pgd, so has no extra memory associated with it.

 */

static inline void pmd_free_kernel(pmd_t *pmd)

{

//        pmd_val(*pmd) = 0;

}

static inline pmd_t *pmd_alloc_kernel(pgd_t *pgd, unsigned long address)

{

        return (pmd_t *) pgd;

}

#define pmd_alloc_one_fast(mm, address) ({ BUG(); ((pmd_t *)1); })

#define pmd_alloc_one(mm,address)       ({ BUG(); ((pmd_t *)2); })

static inline void pte_free(pte_t *pte)

{

        free_page((unsigned long) pte);

}

static inline pte_t *pte_alloc_one(struct mm_struct *mm, unsigned long address)

{

        unsigned long page = __get_free_page(GFP_KERNEL);

        if (!page)

                return NULL;

        memset((void *)page, 0, PAGE_SIZE);

//      pmd_val(*pmd) = SUN3_PMD_MAGIC + __pa(page);

/*      pmd_val(*pmd) = __pa(page); */

        return (pte_t *) (page);

}

#define pte_alloc_one_fast(mm,addr) pte_alloc_one(mm,addr)

#define pmd_populate(mm, pmd, pte) (pmd_val(*pmd) = __pa((unsigned long)pte))

/*

 * allocating and freeing a pmd is trivial: the 1-entry pmd is

 * inside the pgd, so has no extra memory associated with it.

 */

static inline void pmd_free(pmd_t *pmd)

{

        pmd_val(*pmd) = 0;

}

static inline void pgd_free(pgd_t *pgd)

{

        free_page((unsigned long) pgd);

}

static inline pgd_t *pgd_alloc(struct mm_struct *mm)

{

     pgd_t *new_pgd;

     new_pgd = (pgd_t *)get_free_page(GFP_KERNEL);

     memcpy(new_pgd, swapper_pg_dir, PAGE_SIZE);

     memset(new_pgd, 0, (PAGE_OFFSET >> PGDIR_SHIFT));

     return new_pgd;

}

#define pgd_populate(mm, pmd, pte) BUG()

/* FIXME: the sun3 doesn't have a page table cache!

   (but the motorola routine should just return 0) */

extern int do_check_pgt_cache(int, int);

static inline void set_pgdir(unsigned long address, pgd_t entry)

{

}

/* Reserved PMEGs. */

extern char sun3_reserved_pmeg[SUN3_PMEGS_NUM];

extern unsigned long pmeg_vaddr[SUN3_PMEGS_NUM];

extern unsigned char pmeg_alloc[SUN3_PMEGS_NUM];

extern unsigned char pmeg_ctx[SUN3_PMEGS_NUM];

/* Flush all userspace mappings one by one...  (why no flush command,

   sun?) */

static inline void flush_tlb_all(void)

{

       unsigned long addr;

       unsigned char ctx, oldctx;

       oldctx = sun3_get_context();

       for(addr = 0x00000000; addr < TASK_SIZE; addr += SUN3_PMEG_SIZE) {

               for(ctx = 0; ctx < 8; ctx++) {

                       sun3_put_context(ctx);

                       sun3_put_segmap(addr, SUN3_INVALID_PMEG);

               }

       }

       sun3_put_context(oldctx);

       /* erase all of the userspace pmeg maps, we've clobbered them

          all anyway */

       for(addr = 0; addr < SUN3_INVALID_PMEG; addr++) {

               if(pmeg_alloc[addr] == 1) {

                       pmeg_alloc[addr] = 0;

                       pmeg_ctx[addr] = 0;

                       pmeg_vaddr[addr] = 0;

               }

       }

}

/* Clear user TLB entries within the context named in mm */

static inline void flush_tlb_mm (struct mm_struct *mm)

{

     unsigned char oldctx;

     unsigned char seg;

     unsigned long i;

     oldctx = sun3_get_context();

     sun3_put_context(mm->context);

     for(i = 0; i < TASK_SIZE; i += SUN3_PMEG_SIZE) {

             seg = sun3_get_segmap(i);

             if(seg == SUN3_INVALID_PMEG)

                     continue;

             sun3_put_segmap(i, SUN3_INVALID_PMEG);

             pmeg_alloc[seg] = 0;

             pmeg_ctx[seg] = 0;

             pmeg_vaddr[seg] = 0;

     }

     sun3_put_context(oldctx);

}

/* Flush a single TLB page. In this case, we're limited to flushing a

   single PMEG */

static inline void flush_tlb_page (struct vm_area_struct *vma,

                                   unsigned long addr)

{

        unsigned char oldctx;

        unsigned char i;

        oldctx = sun3_get_context();

        sun3_put_context(vma->vm_mm->context);

        addr &= ~SUN3_PMEG_MASK;

        if((i = sun3_get_segmap(addr)) != SUN3_INVALID_PMEG)

        {

                pmeg_alloc[i] = 0;

                pmeg_ctx[i] = 0;

                pmeg_vaddr[i] = 0;

                sun3_put_segmap (addr,  SUN3_INVALID_PMEG);

        }

        sun3_put_context(oldctx);

}

/* Flush a range of pages from TLB. */

static inline void flush_tlb_range (struct mm_struct *mm,

                      unsigned long start, unsigned long end)

{

        unsigned char seg, oldctx;

        start &= ~SUN3_PMEG_MASK;

        oldctx = sun3_get_context();

        sun3_put_context(mm->context);

        while(start < end)

        {

                if((seg = sun3_get_segmap(start)) == SUN3_INVALID_PMEG)

                     goto next;

                if(pmeg_ctx[seg] == mm->context) {

                        pmeg_alloc[seg] = 0;

                        pmeg_ctx[seg] = 0;

                        pmeg_vaddr[seg] = 0;

                }

                sun3_put_segmap(start, SUN3_INVALID_PMEG);

        next:

                start += SUN3_PMEG_SIZE;

        }

}

/* Flush kernel page from TLB. */

static inline void flush_tlb_kernel_page (unsigned long addr)

{

        sun3_put_segmap (addr & ~(SUN3_PMEG_SIZE - 1), SUN3_INVALID_PMEG);

}

static inline void flush_tlb_pgtables(struct mm_struct *mm,

                                      unsigned long start, unsigned long end)

{

}

#endif /* SUN3_PGALLOC_H */