1/* 2 * Copyright 2010 Tilera Corporation. All Rights Reserved. 3 * 4 * This program is free software; you can redistribute it and/or 5 * modify it under the terms of the GNU General Public License 6 * as published by the Free Software Foundation, version 2. 7 * 8 * This program is distributed in the hope that it will be useful, but 9 * WITHOUT ANY WARRANTY; without even the implied warranty of 10 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or 11 * NON INFRINGEMENT. See the GNU General Public License for 12 * more details. 13 */ 14 15#ifndef _ASM_TILE_PAGE_H 16#define _ASM_TILE_PAGE_H 17 18#include <linux/const.h> 19 20/* PAGE_SHIFT and HPAGE_SHIFT determine the page sizes. */ 21#define PAGE_SHIFT 16 22#define HPAGE_SHIFT 24 23 24#define PAGE_SIZE (_AC(1, UL) << PAGE_SHIFT) 25#define HPAGE_SIZE (_AC(1, UL) << HPAGE_SHIFT) 26 27#define PAGE_MASK (~(PAGE_SIZE - 1)) 28#define HPAGE_MASK (~(HPAGE_SIZE - 1)) 29 30#ifdef __KERNEL__ 31 32#include <hv/hypervisor.h> 33#include <arch/chip.h> 34 35/* 36 * The {,H}PAGE_SHIFT values must match the HV_LOG2_PAGE_SIZE_xxx 37 * definitions in <hv/hypervisor.h>. We validate this at build time 38 * here, and again at runtime during early boot. We provide a 39 * separate definition since userspace doesn't have <hv/hypervisor.h>. 40 * 41 * Be careful to distinguish PAGE_SHIFT from HV_PTE_INDEX_PFN, since 42 * they are the same on i386 but not TILE. 43 */ 44#if HV_LOG2_PAGE_SIZE_SMALL != PAGE_SHIFT 45# error Small page size mismatch in Linux 46#endif 47#if HV_LOG2_PAGE_SIZE_LARGE != HPAGE_SHIFT 48# error Huge page size mismatch in Linux 49#endif 50 51#ifndef __ASSEMBLY__ 52 53#include <linux/types.h> 54#include <linux/string.h> 55 56struct page; 57 58static inline void clear_page(void *page) 59{ 60 memset(page, 0, PAGE_SIZE); 61} 62 63static inline void copy_page(void *to, void *from) 64{ 65 memcpy(to, from, PAGE_SIZE); 66} 67 68static inline void clear_user_page(void *page, unsigned long vaddr, 69 struct page *pg) 70{ 71 clear_page(page); 72} 73 74static inline void copy_user_page(void *to, void *from, unsigned long vaddr, 75 struct page *topage) 76{ 77 copy_page(to, from); 78} 79 80/* 81 * Hypervisor page tables are made of the same basic structure. 82 */ 83 84typedef __u64 pteval_t; 85typedef __u64 pmdval_t; 86typedef __u64 pudval_t; 87typedef __u64 pgdval_t; 88typedef __u64 pgprotval_t; 89 90typedef HV_PTE pte_t; 91typedef HV_PTE pgd_t; 92typedef HV_PTE pgprot_t; 93 94/* 95 * User L2 page tables are managed as one L2 page table per page, 96 * because we use the page allocator for them. This keeps the allocation 97 * simple and makes it potentially useful to implement HIGHPTE at some point. 98 * However, it's also inefficient, since L2 page tables are much smaller 99 * than pages (currently 2KB vs 64KB). So we should revisit this. 100 */ 101typedef struct page *pgtable_t; 102 103/* Must be a macro since it is used to create constants. */ 104#define __pgprot(val) hv_pte(val) 105 106static inline u64 pgprot_val(pgprot_t pgprot) 107{ 108 return hv_pte_val(pgprot); 109} 110 111static inline u64 pte_val(pte_t pte) 112{ 113 return hv_pte_val(pte); 114} 115 116static inline u64 pgd_val(pgd_t pgd) 117{ 118 return hv_pte_val(pgd); 119} 120 121#ifdef __tilegx__ 122 123typedef HV_PTE pmd_t; 124 125static inline u64 pmd_val(pmd_t pmd) 126{ 127 return hv_pte_val(pmd); 128} 129 130#endif 131 132static inline __attribute_const__ int get_order(unsigned long size) 133{ 134 return BITS_PER_LONG - __builtin_clzl((size - 1) >> PAGE_SHIFT); 135} 136 137#endif /* !__ASSEMBLY__ */ 138 139#define HUGETLB_PAGE_ORDER (HPAGE_SHIFT - PAGE_SHIFT) 140 141#define HUGE_MAX_HSTATE 2 142 143#ifdef CONFIG_HUGETLB_PAGE 144#define HAVE_ARCH_HUGETLB_UNMAPPED_AREA 145#endif 146 147/* Each memory controller has PAs distinct in their high bits. */ 148#define NR_PA_HIGHBIT_SHIFT (CHIP_PA_WIDTH() - CHIP_LOG_NUM_MSHIMS()) 149#define NR_PA_HIGHBIT_VALUES (1 << CHIP_LOG_NUM_MSHIMS()) 150#define __pa_to_highbits(pa) ((phys_addr_t)(pa) >> NR_PA_HIGHBIT_SHIFT) 151#define __pfn_to_highbits(pfn) ((pfn) >> (NR_PA_HIGHBIT_SHIFT - PAGE_SHIFT)) 152 153#ifdef __tilegx__ 154 155/* 156 * We reserve the lower half of memory for user-space programs, and the 157 * upper half for system code. We re-map all of physical memory in the 158 * upper half, which takes a quarter of our VA space. Then we have 159 * the vmalloc regions. The supervisor code lives at 0xfffffff700000000, 160 * with the hypervisor above that. 161 * 162 * Loadable kernel modules are placed immediately after the static 163 * supervisor code, with each being allocated a 256MB region of 164 * address space, so we don't have to worry about the range of "jal" 165 * and other branch instructions. 166 * 167 * For now we keep life simple and just allocate one pmd (4GB) for vmalloc. 168 * Similarly, for now we don't play any struct page mapping games. 169 */ 170 171#if CHIP_PA_WIDTH() + 2 > CHIP_VA_WIDTH() 172# error Too much PA to map with the VA available! 173#endif 174#define HALF_VA_SPACE (_AC(1, UL) << (CHIP_VA_WIDTH() - 1)) 175 176#define MEM_LOW_END (HALF_VA_SPACE - 1) /* low half */ 177#define MEM_HIGH_START (-HALF_VA_SPACE) /* high half */ 178#define PAGE_OFFSET MEM_HIGH_START 179#define _VMALLOC_START _AC(0xfffffff500000000, UL) /* 4 GB */ 180#define HUGE_VMAP_BASE _AC(0xfffffff600000000, UL) /* 4 GB */ 181#define MEM_SV_START _AC(0xfffffff700000000, UL) /* 256 MB */ 182#define MEM_SV_INTRPT MEM_SV_START 183#define MEM_MODULE_START _AC(0xfffffff710000000, UL) /* 256 MB */ 184#define MEM_MODULE_END (MEM_MODULE_START + (256*1024*1024)) 185#define MEM_HV_START _AC(0xfffffff800000000, UL) /* 32 GB */ 186 187/* Highest DTLB address we will use */ 188#define KERNEL_HIGH_VADDR MEM_SV_START 189 190/* Since we don't currently provide any fixmaps, we use an impossible VA. */ 191#define FIXADDR_TOP MEM_HV_START 192 193#else /* !__tilegx__ */ 194 195/* 196 * A PAGE_OFFSET of 0xC0000000 means that the kernel has 197 * a virtual address space of one gigabyte, which limits the 198 * amount of physical memory you can use to about 768MB. 199 * If you want more physical memory than this then see the CONFIG_HIGHMEM 200 * option in the kernel configuration. 201 * 202 * The top two 16MB chunks in the table below (VIRT and HV) are 203 * unavailable to Linux. Since the kernel interrupt vectors must live 204 * at 0xfd000000, we map all of the bottom of RAM at this address with 205 * a huge page table entry to minimize its ITLB footprint (as well as 206 * at PAGE_OFFSET). The last architected requirement is that user 207 * interrupt vectors live at 0xfc000000, so we make that range of 208 * memory available to user processes. The remaining regions are sized 209 * as shown; after the first four addresses, we show "typical" values, 210 * since the actual addresses depend on kernel #defines. 211 * 212 * MEM_VIRT_INTRPT 0xff000000 213 * MEM_HV_INTRPT 0xfe000000 214 * MEM_SV_INTRPT (kernel code) 0xfd000000 215 * MEM_USER_INTRPT (user vector) 0xfc000000 216 * FIX_KMAP_xxx 0xf8000000 (via NR_CPUS * KM_TYPE_NR) 217 * PKMAP_BASE 0xf7000000 (via LAST_PKMAP) 218 * HUGE_VMAP 0xf3000000 (via CONFIG_NR_HUGE_VMAPS) 219 * VMALLOC_START 0xf0000000 (via __VMALLOC_RESERVE) 220 * mapped LOWMEM 0xc0000000 221 */ 222 223#define MEM_USER_INTRPT _AC(0xfc000000, UL) 224#define MEM_SV_INTRPT _AC(0xfd000000, UL) 225#define MEM_HV_INTRPT _AC(0xfe000000, UL) 226#define MEM_VIRT_INTRPT _AC(0xff000000, UL) 227 228#define INTRPT_SIZE 0x4000 229 230/* Tolerate page size larger than the architecture interrupt region size. */ 231#if PAGE_SIZE > INTRPT_SIZE 232#undef INTRPT_SIZE 233#define INTRPT_SIZE PAGE_SIZE 234#endif 235 236#define KERNEL_HIGH_VADDR MEM_USER_INTRPT 237#define FIXADDR_TOP (KERNEL_HIGH_VADDR - PAGE_SIZE) 238 239#define PAGE_OFFSET _AC(CONFIG_PAGE_OFFSET, UL) 240 241/* On 32-bit architectures we mix kernel modules in with other vmaps. */ 242#define MEM_MODULE_START VMALLOC_START 243#define MEM_MODULE_END VMALLOC_END 244 245#endif /* __tilegx__ */ 246 247#ifndef __ASSEMBLY__ 248 249#ifdef CONFIG_HIGHMEM 250 251/* Map kernel virtual addresses to page frames, in HPAGE_SIZE chunks. */ 252extern unsigned long pbase_map[]; 253extern void *vbase_map[]; 254 255static inline unsigned long kaddr_to_pfn(const volatile void *_kaddr) 256{ 257 unsigned long kaddr = (unsigned long)_kaddr; 258 return pbase_map[kaddr >> HPAGE_SHIFT] + 259 ((kaddr & (HPAGE_SIZE - 1)) >> PAGE_SHIFT); 260} 261 262static inline void *pfn_to_kaddr(unsigned long pfn) 263{ 264 return vbase_map[__pfn_to_highbits(pfn)] + (pfn << PAGE_SHIFT); 265} 266 267static inline phys_addr_t virt_to_phys(const volatile void *kaddr) 268{ 269 unsigned long pfn = kaddr_to_pfn(kaddr); 270 return ((phys_addr_t)pfn << PAGE_SHIFT) + 271 ((unsigned long)kaddr & (PAGE_SIZE-1)); 272} 273 274static inline void *phys_to_virt(phys_addr_t paddr) 275{ 276 return pfn_to_kaddr(paddr >> PAGE_SHIFT) + (paddr & (PAGE_SIZE-1)); 277} 278 279/* With HIGHMEM, we pack PAGE_OFFSET through high_memory with all valid VAs. */ 280static inline int virt_addr_valid(const volatile void *kaddr) 281{ 282 extern void *high_memory; /* copied from <linux/mm.h> */ 283 return ((unsigned long)kaddr >= PAGE_OFFSET && kaddr < high_memory); 284} 285 286#else /* !CONFIG_HIGHMEM */ 287 288static inline unsigned long kaddr_to_pfn(const volatile void *kaddr) 289{ 290 return ((unsigned long)kaddr - PAGE_OFFSET) >> PAGE_SHIFT; 291} 292 293static inline void *pfn_to_kaddr(unsigned long pfn) 294{ 295 return (void *)((pfn << PAGE_SHIFT) + PAGE_OFFSET); 296} 297 298static inline phys_addr_t virt_to_phys(const volatile void *kaddr) 299{ 300 return (phys_addr_t)((unsigned long)kaddr - PAGE_OFFSET); 301} 302 303static inline void *phys_to_virt(phys_addr_t paddr) 304{ 305 return (void *)((unsigned long)paddr + PAGE_OFFSET); 306} 307 308/* Check that the given address is within some mapped range of PAs. */ 309#define virt_addr_valid(kaddr) pfn_valid(kaddr_to_pfn(kaddr)) 310 311#endif /* !CONFIG_HIGHMEM */ 312 313/* All callers are not consistent in how they call these functions. */ 314#define __pa(kaddr) virt_to_phys((void *)(unsigned long)(kaddr)) 315#define __va(paddr) phys_to_virt((phys_addr_t)(paddr)) 316 317extern int devmem_is_allowed(unsigned long pagenr); 318 319#ifdef CONFIG_FLATMEM 320static inline int pfn_valid(unsigned long pfn) 321{ 322 return pfn < max_mapnr; 323} 324#endif 325 326/* Provide as macros since these require some other headers included. */ 327#define page_to_pa(page) ((phys_addr_t)(page_to_pfn(page)) << PAGE_SHIFT) 328#define virt_to_page(kaddr) pfn_to_page(kaddr_to_pfn(kaddr)) 329#define page_to_virt(page) pfn_to_kaddr(page_to_pfn(page)) 330 331struct mm_struct; 332extern pte_t *virt_to_pte(struct mm_struct *mm, unsigned long addr); 333 334#endif /* !__ASSEMBLY__ */ 335 336#define VM_DATA_DEFAULT_FLAGS \ 337 (VM_READ | VM_WRITE | VM_MAYREAD | VM_MAYWRITE | VM_MAYEXEC) 338 339#include <asm-generic/memory_model.h> 340 341#endif /* __KERNEL__ */ 342 343#endif /* _ASM_TILE_PAGE_H */ 344