开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
srmmu.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：64k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

srmmu.c：源码内容
  1. /* $Id: srmmu.c,v 1.233 2001/11/13 00:49:27 davem Exp $
  2.  * srmmu.c:  SRMMU specific routines for memory management.
  3.  *
  4.  * Copyright (C) 1995 David S. Miller  (davem@caip.rutgers.edu)
  5.  * Copyright (C) 1995 Pete Zaitcev
  6.  * Copyright (C) 1996 Eddie C. Dost    (ecd@skynet.be)
  7.  * Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
  8.  * Copyright (C) 1999,2000 Anton Blanchard (anton@samba.org)
  9.  */
  11. #include <linux/config.h>
  12. #include <linux/kernel.h>
  13. #include <linux/mm.h>
  14. #include <linux/slab.h>
  15. #include <linux/vmalloc.h>
  16. #include <linux/pagemap.h>
  17. #include <linux/init.h>
  18. #include <linux/blk.h>
  19. #include <linux/spinlock.h>
  20. #include <linux/bootmem.h>
  21. #include <linux/fs.h>
  22. #include <linux/seq_file.h>
  24. #include <asm/page.h>
  25. #include <asm/pgalloc.h>
  26. #include <asm/pgtable.h>
  27. #include <asm/io.h>
  28. #include <asm/kdebug.h>
  29. #include <asm/vaddrs.h>
  30. #include <asm/traps.h>
  31. #include <asm/smp.h>
  32. #include <asm/mbus.h>
  33. #include <asm/cache.h>
  34. #include <asm/oplib.h>
  35. #include <asm/sbus.h>
  36. #include <asm/asi.h>
  37. #include <asm/msi.h>
  38. #include <asm/a.out.h>
  39. #include <asm/mmu_context.h>
  40. #include <asm/io-unit.h>
  42. /* Now the cpu specific definitions. */
  43. #include <asm/viking.h>
  44. #include <asm/mxcc.h>
  45. #include <asm/ross.h>
  46. #include <asm/tsunami.h>
  47. #include <asm/swift.h>
  48. #include <asm/turbosparc.h>
  50. #include <asm/btfixup.h>
  52. enum mbus_module srmmu_modtype;
  53. unsigned int hwbug_bitmask;
  54. int vac_cache_size;
  55. int vac_line_size;
  57. extern struct resource sparc_iomap;
  59. extern unsigned long last_valid_pfn;
  61. extern unsigned long page_kernel;
  63. pgd_t *srmmu_swapper_pg_dir;
  65. #ifdef CONFIG_SMP
  66. #define FLUSH_BEGIN(mm)
  67. #define FLUSH_END
  68. #else
  69. #define FLUSH_BEGIN(mm) if((mm)->context != NO_CONTEXT) {
  70. #define FLUSH_END }
  71. #endif
  73. BTFIXUPDEF_CALL(void, flush_page_for_dma, unsigned long)
  74. #define flush_page_for_dma(page) BTFIXUP_CALL(flush_page_for_dma)(page)
  76. int flush_page_for_dma_global = 1;
  78. #ifdef CONFIG_SMP
  79. BTFIXUPDEF_CALL(void, local_flush_page_for_dma, unsigned long)
  80. #define local_flush_page_for_dma(page) BTFIXUP_CALL(local_flush_page_for_dma)(page)
  81. #endif
  83. char *srmmu_name;
  85. ctxd_t *srmmu_ctx_table_phys;
  86. ctxd_t *srmmu_context_table;
  88. int viking_mxcc_present;
  89. spinlock_t srmmu_context_spinlock = SPIN_LOCK_UNLOCKED;
  91. int is_hypersparc;
  93. /*
  94.  * In general all page table modifications should use the V8 atomic
  95.  * swap instruction.  This insures the mmu and the cpu are in sync
  96.  * with respect to ref/mod bits in the page tables.
  97.  */
  98. static inline unsigned long srmmu_swap(unsigned long *addr, unsigned long value)
  99. {
  100. __asm__ __volatile__("swap [%2], %0" : "=&r" (value) : "0" (value), "r" (addr));
  101. return value;
  102. }
  104. static inline void srmmu_set_pte(pte_t *ptep, pte_t pteval)
  105. {
  106. srmmu_swap((unsigned long *)ptep, pte_val(pteval));
  107. }
  109. /* The very generic SRMMU page table operations. */
  110. static inline int srmmu_device_memory(unsigned long x)
  111. {
  112. return ((x & 0xF0000000) != 0);
  113. }
  115. int srmmu_cache_pagetables;
  117. /* these will be initialized in srmmu_nocache_calcsize() */
  118. int srmmu_nocache_npages;
  119. unsigned long srmmu_nocache_size;
  120. unsigned long srmmu_nocache_end;
  121. unsigned long pkmap_base;
  122. unsigned long pkmap_base_end;
  123. unsigned long srmmu_nocache_bitmap_size;
  124. extern unsigned long fix_kmap_begin;
  125. extern unsigned long fix_kmap_end;
  127. #define SRMMU_NOCACHE_BITMAP_SHIFT (PAGE_SHIFT - 4)
  129. void *srmmu_nocache_pool;
  130. void *srmmu_nocache_bitmap;
  131. int srmmu_nocache_low;
  132. int srmmu_nocache_used;
  133. spinlock_t srmmu_nocache_spinlock;
  135. /* This makes sense. Honest it does - Anton */
  136. #define __nocache_pa(VADDR) (((unsigned long)VADDR) - SRMMU_NOCACHE_VADDR + __pa((unsigned long)srmmu_nocache_pool))
  137. #define __nocache_va(PADDR) (__va((unsigned long)PADDR) - (unsigned long)srmmu_nocache_pool + SRMMU_NOCACHE_VADDR)
  138. #define __nocache_fix(VADDR) __va(__nocache_pa(VADDR))
  140. static inline unsigned long srmmu_pgd_page(pgd_t pgd)
  141. { return srmmu_device_memory(pgd_val(pgd))?~0:(unsigned long)__nocache_va((pgd_val(pgd) & SRMMU_PTD_PMASK) << 4); }
  143. static inline unsigned long srmmu_pmd_page(pmd_t pmd)
  144. { return srmmu_device_memory(pmd_val(pmd))?~0:(unsigned long)__nocache_va((pmd_val(pmd) & SRMMU_PTD_PMASK) << 4); }
  146. static inline struct page *srmmu_pte_page(pte_t pte)
  147. { return (mem_map + (unsigned long)(srmmu_device_memory(pte_val(pte))?~0:(((pte_val(pte) & SRMMU_PTE_PMASK) << 4) >> PAGE_SHIFT))); }
  149. static inline int srmmu_pte_none(pte_t pte)
  150. { return !(pte_val(pte) & 0xFFFFFFF); }
  152. static inline int srmmu_pte_present(pte_t pte)
  153. { return ((pte_val(pte) & SRMMU_ET_MASK) == SRMMU_ET_PTE); }
  155. static inline void srmmu_pte_clear(pte_t *ptep)
  156. { srmmu_set_pte(ptep, __pte(0)); }
  158. static inline int srmmu_pmd_none(pmd_t pmd)
  159. { return !(pmd_val(pmd) & 0xFFFFFFF); }
  161. static inline int srmmu_pmd_bad(pmd_t pmd)
  162. { return (pmd_val(pmd) & SRMMU_ET_MASK) != SRMMU_ET_PTD; }
  164. static inline int srmmu_pmd_present(pmd_t pmd)
  165. { return ((pmd_val(pmd) & SRMMU_ET_MASK) == SRMMU_ET_PTD); }
  167. static inline void srmmu_pmd_clear(pmd_t *pmdp)
  168. { srmmu_set_pte((pte_t *)pmdp, __pte(0)); }
  170. static inline int srmmu_pgd_none(pgd_t pgd)          
  171. { return !(pgd_val(pgd) & 0xFFFFFFF); }
  173. static inline int srmmu_pgd_bad(pgd_t pgd)
  174. { return (pgd_val(pgd) & SRMMU_ET_MASK) != SRMMU_ET_PTD; }
  176. static inline int srmmu_pgd_present(pgd_t pgd)
  177. { return ((pgd_val(pgd) & SRMMU_ET_MASK) == SRMMU_ET_PTD); }
  179. static inline void srmmu_pgd_clear(pgd_t * pgdp)
  180. { srmmu_set_pte((pte_t *)pgdp, __pte(0)); }
  182. static inline int srmmu_pte_write(pte_t pte)
  183. { return pte_val(pte) & SRMMU_WRITE; }
  185. static inline int srmmu_pte_dirty(pte_t pte)
  186. { return pte_val(pte) & SRMMU_DIRTY; }
  188. static inline int srmmu_pte_young(pte_t pte)
  189. { return pte_val(pte) & SRMMU_REF; }
  191. static inline pte_t srmmu_pte_wrprotect(pte_t pte)
  192. { return __pte(pte_val(pte) & ~SRMMU_WRITE);}
  194. static inline pte_t srmmu_pte_mkclean(pte_t pte)
  195. { return __pte(pte_val(pte) & ~SRMMU_DIRTY);}
  197. static inline pte_t srmmu_pte_mkold(pte_t pte)
  198. { return __pte(pte_val(pte) & ~SRMMU_REF);}
  200. static inline pte_t srmmu_pte_mkwrite(pte_t pte)
  201. { return __pte(pte_val(pte) | SRMMU_WRITE);}
  203. static inline pte_t srmmu_pte_mkdirty(pte_t pte)
  204. { return __pte(pte_val(pte) | SRMMU_DIRTY);}
  206. static inline pte_t srmmu_pte_mkyoung(pte_t pte)
  207. { return __pte(pte_val(pte) | SRMMU_REF);}
  209. /*
  210.  * Conversion functions: convert a page and protection to a page entry,
  211.  * and a page entry and page directory to the page they refer to.
  212.  */
  213. static pte_t srmmu_mk_pte(struct page *page, pgprot_t pgprot)
  214. { return __pte((((page - mem_map) << PAGE_SHIFT) >> 4) | pgprot_val(pgprot)); }
  216. static pte_t srmmu_mk_pte_phys(unsigned long page, pgprot_t pgprot)
  217. { return __pte(((page) >> 4) | pgprot_val(pgprot)); }
  219. static pte_t srmmu_mk_pte_io(unsigned long page, pgprot_t pgprot, int space)
  220. { return __pte(((page) >> 4) | (space << 28) | pgprot_val(pgprot)); }
  222. /* XXX should we hyper_flush_whole_icache here - Anton */
  223. static inline void srmmu_ctxd_set(ctxd_t *ctxp, pgd_t *pgdp)
  224. { srmmu_set_pte((pte_t *)ctxp, (SRMMU_ET_PTD | (__nocache_pa((unsigned long) pgdp) >> 4))); }
  226. static inline void srmmu_pgd_set(pgd_t * pgdp, pmd_t * pmdp)
  227. { srmmu_set_pte((pte_t *)pgdp, (SRMMU_ET_PTD | (__nocache_pa((unsigned long) pmdp) >> 4))); }
  229. static inline void srmmu_pmd_set(pmd_t * pmdp, pte_t * ptep)
  230. { srmmu_set_pte((pte_t *)pmdp, (SRMMU_ET_PTD | (__nocache_pa((unsigned long) ptep) >> 4))); }
  232. static inline pte_t srmmu_pte_modify(pte_t pte, pgprot_t newprot)
  233. { return __pte((pte_val(pte) & SRMMU_CHG_MASK) | pgprot_val(newprot)); }
  235. /* to find an entry in a top-level page table... */
  236. extern inline pgd_t *srmmu_pgd_offset(struct mm_struct * mm, unsigned long address)
  237. { return mm->pgd + (address >> SRMMU_PGDIR_SHIFT); }
  239. /* Find an entry in the second-level page table.. */
  240. static inline pmd_t *srmmu_pmd_offset(pgd_t * dir, unsigned long address)
  241. { return (pmd_t *) srmmu_pgd_page(*dir) + ((address >> SRMMU_PMD_SHIFT) & (SRMMU_PTRS_PER_PMD - 1)); }
  243. /* Find an entry in the third-level page table.. */ 
  244. static inline pte_t *srmmu_pte_offset(pmd_t * dir, unsigned long address)
  245. { return (pte_t *) srmmu_pmd_page(*dir) + ((address >> PAGE_SHIFT) & (SRMMU_PTRS_PER_PTE - 1)); }
  247. unsigned long __srmmu_get_nocache(int size, int align)
  248. {
  249. int offset = srmmu_nocache_low;
  250. int i;
  251. unsigned long va_tmp, phys_tmp;
  252. int lowest_failed = 0;
  254. size = size >> SRMMU_NOCACHE_BITMAP_SHIFT;
  256. spin_lock(&srmmu_nocache_spinlock);
  258. repeat:
  259. offset = find_next_zero_bit(srmmu_nocache_bitmap, srmmu_nocache_bitmap_size, offset);
  261. /* we align on physical address */
  262. if (align) {
  263. va_tmp = (SRMMU_NOCACHE_VADDR + (offset << SRMMU_NOCACHE_BITMAP_SHIFT));
  264. phys_tmp = (__nocache_pa(va_tmp) + align - 1) & ~(align - 1);
  265. va_tmp = (unsigned long)__nocache_va(phys_tmp);
  266. offset = (va_tmp - SRMMU_NOCACHE_VADDR) >> SRMMU_NOCACHE_BITMAP_SHIFT;
  267. }
  269. if ((srmmu_nocache_bitmap_size - offset) < size) {
  270. printk("Run out of nocached RAM!n");
  271. spin_unlock(&srmmu_nocache_spinlock);
  272. return 0;
  273. }
  275. i = 0;
  276. while(i < size) {
  277. if (test_bit(offset + i, srmmu_nocache_bitmap)) {
  278. lowest_failed = 1;
  279. offset = offset + i + 1;
  280. goto repeat;
  281. }
  282. i++;
  283. }
  285. i = 0;
  286. while(i < size) {
  287. set_bit(offset + i, srmmu_nocache_bitmap);
  288. i++;
  289. srmmu_nocache_used++;
  290. }
  292. if (!lowest_failed && ((align >> SRMMU_NOCACHE_BITMAP_SHIFT) <= 1) && (offset > srmmu_nocache_low))
  293. srmmu_nocache_low = offset;
  295. spin_unlock(&srmmu_nocache_spinlock);
  297. return (SRMMU_NOCACHE_VADDR + (offset << SRMMU_NOCACHE_BITMAP_SHIFT));
  298. }
  300. unsigned inline long srmmu_get_nocache(int size, int align)
  301. {
  302. unsigned long tmp;
  304. tmp = __srmmu_get_nocache(size, align);
  306. if (tmp)
  307. memset((void *)tmp, 0, size);
  309. return tmp;
  310. }
  312. void srmmu_free_nocache(unsigned long vaddr, int size)
  313. {
  314. int offset = (vaddr - SRMMU_NOCACHE_VADDR) >> SRMMU_NOCACHE_BITMAP_SHIFT;
  316. size = size >> SRMMU_NOCACHE_BITMAP_SHIFT;
  318. spin_lock(&srmmu_nocache_spinlock);
  320. while(size--) {
  321. clear_bit(offset + size, srmmu_nocache_bitmap);
  322. srmmu_nocache_used--;
  323. }
  325. if (offset < srmmu_nocache_low)
  326. srmmu_nocache_low = offset;
  328. spin_unlock(&srmmu_nocache_spinlock);
  329. }
  331. void srmmu_early_allocate_ptable_skeleton(unsigned long start, unsigned long end);
  333. extern unsigned long probe_memory(void); /* in fault.c */
  335. /* Reserve nocache dynamically proportionally to the amount of
  336.  * system RAM. -- Tomas Szepe <szepe@pinerecords.com>, June 2002
  337.  */
  338. void srmmu_nocache_calcsize(void)
  339. {
  340. unsigned long sysmemavail = probe_memory() / 1024;
  342. srmmu_nocache_npages =
  343. sysmemavail / SRMMU_NOCACHE_ALCRATIO / 1024 * 256;
  344. if (sysmemavail % (SRMMU_NOCACHE_ALCRATIO * 1024))
  345. srmmu_nocache_npages += 256;
  347. /* anything above 1280 blows up */
  348. if (srmmu_nocache_npages > 1280) srmmu_nocache_npages = 1280;
  350. srmmu_nocache_size = srmmu_nocache_npages * PAGE_SIZE;
  351. srmmu_nocache_bitmap_size = srmmu_nocache_npages * 16;
  352. srmmu_nocache_end = SRMMU_NOCACHE_VADDR + srmmu_nocache_size;
  353. fix_kmap_begin = srmmu_nocache_end;
  354. fix_kmap_end = fix_kmap_begin + (KM_TYPE_NR * NR_CPUS - 1) * PAGE_SIZE;
  355. pkmap_base = SRMMU_NOCACHE_VADDR + srmmu_nocache_size + 0x40000;
  356. pkmap_base_end = pkmap_base + LAST_PKMAP * PAGE_SIZE;
  358. /* printk("system memory available = %luknnocache ram size = %lukn",
  359. sysmemavail, srmmu_nocache_size / 1024); */
  360. }
  362. void srmmu_nocache_init(void)
  363. {
  364. pgd_t *pgd;
  365. pmd_t *pmd;
  366. pte_t *pte;
  367. unsigned long paddr, vaddr;
  368. unsigned long pteval;
  370. srmmu_nocache_pool = __alloc_bootmem(srmmu_nocache_size, PAGE_SIZE, 0UL);
  371. memset(srmmu_nocache_pool, 0, srmmu_nocache_size);
  373. srmmu_nocache_bitmap = __alloc_bootmem(srmmu_nocache_bitmap_size, SMP_CACHE_BYTES, 0UL);
  374. memset(srmmu_nocache_bitmap, 0, srmmu_nocache_bitmap_size);
  376. srmmu_swapper_pg_dir = (pgd_t *)__srmmu_get_nocache(SRMMU_PGD_TABLE_SIZE, SRMMU_PGD_TABLE_SIZE);
  377. memset(__nocache_fix(srmmu_swapper_pg_dir), 0, SRMMU_PGD_TABLE_SIZE);
  378. init_mm.pgd = srmmu_swapper_pg_dir;
  380. srmmu_early_allocate_ptable_skeleton(SRMMU_NOCACHE_VADDR, srmmu_nocache_end);
  382. spin_lock_init(&srmmu_nocache_spinlock);
  384. paddr = __pa((unsigned long)srmmu_nocache_pool);
  385. vaddr = SRMMU_NOCACHE_VADDR;
  387. while (vaddr < srmmu_nocache_end) {
  388. pgd = pgd_offset_k(vaddr);
  389. pmd = srmmu_pmd_offset(__nocache_fix(pgd), vaddr);
  390. pte = srmmu_pte_offset(__nocache_fix(pmd), vaddr);
  392. pteval = ((paddr >> 4) | SRMMU_ET_PTE | SRMMU_PRIV);
  394. if (srmmu_cache_pagetables)
  395. pteval |= SRMMU_CACHE;
  397. srmmu_set_pte(__nocache_fix(pte), pteval);
  399. vaddr += PAGE_SIZE;
  400. paddr += PAGE_SIZE;
  401. }
  403. flush_cache_all();
  404. flush_tlb_all();
  405. }
  407. static inline pgd_t *srmmu_get_pgd_fast(void)
  408. {
  409. pgd_t *pgd = NULL;
  411. pgd = (pgd_t *)__srmmu_get_nocache(SRMMU_PGD_TABLE_SIZE, SRMMU_PGD_TABLE_SIZE);
  412. if (pgd) {
  413. pgd_t *init = pgd_offset_k(0);
  414. memset(pgd, 0, USER_PTRS_PER_PGD * sizeof(pgd_t));
  415. memcpy(pgd + USER_PTRS_PER_PGD, init + USER_PTRS_PER_PGD,
  416. (PTRS_PER_PGD - USER_PTRS_PER_PGD) * sizeof(pgd_t));
  417. }
  419. return pgd;
  420. }
  422. static void srmmu_free_pgd_fast(pgd_t *pgd)
  423. {
  424. srmmu_free_nocache((unsigned long)pgd, SRMMU_PGD_TABLE_SIZE);
  425. }
  427. static pte_t *srmmu_pte_alloc_one_fast(struct mm_struct *mm, unsigned long address)
  428. {
  429. return (pte_t *)srmmu_get_nocache(SRMMU_PTE_TABLE_SIZE, SRMMU_PTE_TABLE_SIZE);
  430. }
  432. static pte_t *srmmu_pte_alloc_one(struct mm_struct *mm, unsigned long address)
  433. {
  434. return NULL;
  435. }
  437. static void srmmu_free_pte_fast(pte_t *pte)
  438. {
  439. srmmu_free_nocache((unsigned long)pte, SRMMU_PTE_TABLE_SIZE);
  440. }
  442. static pmd_t *srmmu_pmd_alloc_one_fast(struct mm_struct *mm, unsigned long address)
  443. {
  444. return (pmd_t *)srmmu_get_nocache(SRMMU_PMD_TABLE_SIZE, SRMMU_PMD_TABLE_SIZE);
  445. }
  447. static void srmmu_free_pmd_fast(pmd_t * pmd)
  448. {
  449. srmmu_free_nocache((unsigned long)pmd, SRMMU_PMD_TABLE_SIZE);
  450. }
  452. static inline void alloc_context(struct mm_struct *old_mm, struct mm_struct *mm)
  453. {
  454. struct ctx_list *ctxp;
  456. ctxp = ctx_free.next;
  457. if(ctxp != &ctx_free) {
  458. remove_from_ctx_list(ctxp);
  459. add_to_used_ctxlist(ctxp);
  460. mm->context = ctxp->ctx_number;
  461. ctxp->ctx_mm = mm;
  462. return;
  463. }
  464. ctxp = ctx_used.next;
  465. if(ctxp->ctx_mm == old_mm)
  466. ctxp = ctxp->next;
  467. if(ctxp == &ctx_used)
  468. panic("out of mmu contexts");
  469. flush_cache_mm(ctxp->ctx_mm);
  470. flush_tlb_mm(ctxp->ctx_mm);
  471. remove_from_ctx_list(ctxp);
  472. add_to_used_ctxlist(ctxp);
  473. ctxp->ctx_mm->context = NO_CONTEXT;
  474. ctxp->ctx_mm = mm;
  475. mm->context = ctxp->ctx_number;
  476. }
  478. static inline void free_context(int context)
  479. {
  480. struct ctx_list *ctx_old;
  482. ctx_old = ctx_list_pool + context;
  483. remove_from_ctx_list(ctx_old);
  484. add_to_free_ctxlist(ctx_old);
  485. }
  488. static void srmmu_switch_mm(struct mm_struct *old_mm, struct mm_struct *mm,
  489.     struct task_struct *tsk, int cpu)
  490. {
  491. if(mm->context == NO_CONTEXT) {
  492. spin_lock(&srmmu_context_spinlock);
  493. alloc_context(old_mm, mm);
  494. spin_unlock(&srmmu_context_spinlock);
  495. srmmu_ctxd_set(&srmmu_context_table[mm->context], mm->pgd);
  496. }
  498. if (is_hypersparc)
  499. hyper_flush_whole_icache();
  501. srmmu_set_context(mm->context);
  502. }
  504. /* Low level IO area allocation on the SRMMU. */
  505. void srmmu_mapioaddr(unsigned long physaddr, unsigned long virt_addr, int bus_type, int rdonly)
  506. {
  507. pgd_t *pgdp;
  508. pmd_t *pmdp;
  509. pte_t *ptep;
  510. unsigned long tmp;
  512. physaddr &= PAGE_MASK;
  513. pgdp = pgd_offset_k(virt_addr);
  514. pmdp = srmmu_pmd_offset(pgdp, virt_addr);
  515. ptep = srmmu_pte_offset(pmdp, virt_addr);
  516. tmp = (physaddr >> 4) | SRMMU_ET_PTE;
  518. /*
  519.  * I need to test whether this is consistent over all
  520.  * sun4m's.  The bus_type represents the upper 4 bits of
  521.  * 36-bit physical address on the I/O space lines...
  522.  */
  523. tmp |= (bus_type << 28);
  524. if(rdonly)
  525. tmp |= SRMMU_PRIV_RDONLY;
  526. else
  527. tmp |= SRMMU_PRIV;
  528. __flush_page_to_ram(virt_addr);
  529. srmmu_set_pte(ptep, __pte(tmp));
  530. flush_tlb_all();
  531. }
  533. void srmmu_unmapioaddr(unsigned long virt_addr)
  534. {
  535. pgd_t *pgdp;
  536. pmd_t *pmdp;
  537. pte_t *ptep;
  539. pgdp = pgd_offset_k(virt_addr);
  540. pmdp = srmmu_pmd_offset(pgdp, virt_addr);
  541. ptep = srmmu_pte_offset(pmdp, virt_addr);
  543. /* No need to flush uncacheable page. */
  544. srmmu_pte_clear(ptep);
  545. flush_tlb_all();
  546. }
  548. /*
  549.  * On the SRMMU we do not have the problems with limited tlb entries
  550.  * for mapping kernel pages, so we just take things from the free page
  551.  * pool.  As a side effect we are putting a little too much pressure
  552.  * on the gfp() subsystem.  This setup also makes the logic of the
  553.  * iommu mapping code a lot easier as we can transparently handle
  554.  * mappings on the kernel stack without any special code as we did
  555.  * need on the sun4c.
  556.  */
  557. struct task_struct *srmmu_alloc_task_struct(void)
  558. {
  559. return (struct task_struct *) __get_free_pages(GFP_KERNEL, 1);
  560. }
  562. static void srmmu_free_task_struct(struct task_struct *tsk)
  563. {
  564. free_pages((unsigned long)tsk, 1);
  565. }
  567. static void srmmu_get_task_struct(struct task_struct *tsk)
  568. {
  569. atomic_inc(&virt_to_page(tsk)->count);
  570. }
  572. /* tsunami.S */
  573. extern void tsunami_flush_cache_all(void);
  574. extern void tsunami_flush_cache_mm(struct mm_struct *mm);
  575. extern void tsunami_flush_cache_range(struct mm_struct *mm, unsigned long start, unsigned long end);
  576. extern void tsunami_flush_cache_page(struct vm_area_struct *vma, unsigned long page);
  577. extern void tsunami_flush_page_to_ram(unsigned long page);
  578. extern void tsunami_flush_page_for_dma(unsigned long page);
  579. extern void tsunami_flush_sig_insns(struct mm_struct *mm, unsigned long insn_addr);
  580. extern void tsunami_flush_tlb_all(void);
  581. extern void tsunami_flush_tlb_mm(struct mm_struct *mm);
  582. extern void tsunami_flush_tlb_range(struct mm_struct *mm, unsigned long start, unsigned long end);
  583. extern void tsunami_flush_tlb_page(struct vm_area_struct *vma, unsigned long page);
  584. extern void tsunami_setup_blockops(void);
  586. /*
  587.  * Workaround, until we find what's going on with Swift. When low on memory,
  588.  * it sometimes loops in fault/handle_mm_fault incl. flush_tlb_page to find
  589.  * out it is already in page tables/ fault again on the same instruction.
  590.  * I really don't understand it, have checked it and contexts
  591.  * are right, flush_tlb_all is done as well, and it faults again...
  592.  * Strange. -jj
  593.  *
  594.  * The following code is a deadwood that may be necessary when
  595.  * we start to make precise page flushes again. --zaitcev
  596.  */
  597. static void swift_update_mmu_cache(struct vm_area_struct * vma, unsigned long address, pte_t pte)
  598. {
  599. #if 0
  600. static unsigned long last;
  601. unsigned int val;
  602. /* unsigned int n; */
  604. if (address == last) {
  605. val = srmmu_hwprobe(address);
  606. if (val != 0 && pte_val(pte) != val) {
  607. printk("swift_update_mmu_cache: "
  608.     "addr %lx put %08x probed %08x from %pn",
  609.     address, pte_val(pte), val,
  610.     __builtin_return_address(0));
  611. srmmu_flush_whole_tlb();
  612. }
  613. }
  614. last = address;
  615. #endif
  616. }
  618. /* swift.S */
  619. extern void swift_flush_cache_all(void);
  620. extern void swift_flush_cache_mm(struct mm_struct *mm);
  621. extern void swift_flush_cache_range(struct mm_struct *mm,
  622.     unsigned long start, unsigned long end);
  623. extern void swift_flush_cache_page(struct vm_area_struct *vma, unsigned long page);
  624. extern void swift_flush_page_to_ram(unsigned long page);
  625. extern void swift_flush_page_for_dma(unsigned long page);
  626. extern void swift_flush_sig_insns(struct mm_struct *mm, unsigned long insn_addr);
  627. extern void swift_flush_tlb_all(void);
  628. extern void swift_flush_tlb_mm(struct mm_struct *mm);
  629. extern void swift_flush_tlb_range(struct mm_struct *mm,
  630.   unsigned long start, unsigned long end);
  631. extern void swift_flush_tlb_page(struct vm_area_struct *vma, unsigned long page);
  633. #if 0  /* P3: deadwood to debug precise flushes on Swift. */
  634. void swift_flush_tlb_page(struct vm_area_struct *vma, unsigned long page)
  635. {
  636. int cctx, ctx1;
  638. page &= PAGE_MASK;
  639. if ((ctx1 = vma->vm_mm->context) != -1) {
  640. cctx = srmmu_get_context();
  641. /* Is context # ever different from current context? P3 */
  642. if (cctx != ctx1) {
  643. printk("flush ctx %02x curr %02xn", ctx1, cctx);
  644. srmmu_set_context(ctx1);
  645. swift_flush_page(page);
  646. __asm__ __volatile__("sta %%g0, [%0] %1nt" : :
  647. "r" (page), "i" (ASI_M_FLUSH_PROBE));
  648. srmmu_set_context(cctx);
  649. } else {
  650.  /* Rm. prot. bits from virt. c. */
  651. /* swift_flush_cache_all(); */
  652. /* swift_flush_cache_page(vma, page); */
  653. swift_flush_page(page);
  655. __asm__ __volatile__("sta %%g0, [%0] %1nt" : :
  656. "r" (page), "i" (ASI_M_FLUSH_PROBE));
  657. /* same as above: srmmu_flush_tlb_page() */
  658. }
  659. }
  660. }
  661. #endif
  663. /*
  664.  * The following are all MBUS based SRMMU modules, and therefore could
  665.  * be found in a multiprocessor configuration.  On the whole, these
  666.  * chips seems to be much more touchy about DVMA and page tables
  667.  * with respect to cache coherency.
  668.  */
  670. /* Cypress flushes. */
  671. static void cypress_flush_cache_all(void)
  672. {
  673. volatile unsigned long cypress_sucks;
  674. unsigned long faddr, tagval;
  676. flush_user_windows();
  677. for(faddr = 0; faddr < 0x10000; faddr += 0x20) {
  678. __asm__ __volatile__("lda [%1 + %2] %3, %0nt" :
  679.      "=r" (tagval) :
  680.      "r" (faddr), "r" (0x40000),
  681.      "i" (ASI_M_DATAC_TAG));
  683. /* If modified and valid, kick it. */
  684. if((tagval & 0x60) == 0x60)
  685. cypress_sucks = *(unsigned long *)(0xf0020000 + faddr);
  686. }
  687. }
  689. static void cypress_flush_cache_mm(struct mm_struct *mm)
  690. {
  691. register unsigned long a, b, c, d, e, f, g;
  692. unsigned long flags, faddr;
  693. int octx;
  695. FLUSH_BEGIN(mm)
  696. flush_user_windows();
  697. __save_and_cli(flags);
  698. octx = srmmu_get_context();
  699. srmmu_set_context(mm->context);
  700. a = 0x20; b = 0x40; c = 0x60;
  701. d = 0x80; e = 0xa0; f = 0xc0; g = 0xe0;
  703. faddr = (0x10000 - 0x100);
  704. goto inside;
  705. do {
  706. faddr -= 0x100;
  707. inside:
  708. __asm__ __volatile__("sta %%g0, [%0] %1nt"
  709.      "sta %%g0, [%0 + %2] %1nt"
  710.      "sta %%g0, [%0 + %3] %1nt"
  711.      "sta %%g0, [%0 + %4] %1nt"
  712.      "sta %%g0, [%0 + %5] %1nt"
  713.      "sta %%g0, [%0 + %6] %1nt"
  714.      "sta %%g0, [%0 + %7] %1nt"
  715.      "sta %%g0, [%0 + %8] %1nt" : :
  716.      "r" (faddr), "i" (ASI_M_FLUSH_CTX),
  717.      "r" (a), "r" (b), "r" (c), "r" (d),
  718.      "r" (e), "r" (f), "r" (g));
  719. } while(faddr);
  720. srmmu_set_context(octx);
  721. __restore_flags(flags);
  722. FLUSH_END
  723. }
  725. static void cypress_flush_cache_range(struct mm_struct *mm, unsigned long start, unsigned long end)
  726. {
  727. register unsigned long a, b, c, d, e, f, g;
  728. unsigned long flags, faddr;
  729. int octx;
  731. FLUSH_BEGIN(mm)
  732. flush_user_windows();
  733. __save_and_cli(flags);
  734. octx = srmmu_get_context();
  735. srmmu_set_context(mm->context);
  736. a = 0x20; b = 0x40; c = 0x60;
  737. d = 0x80; e = 0xa0; f = 0xc0; g = 0xe0;
  739. start &= SRMMU_PMD_MASK;
  740. while(start < end) {
  741. faddr = (start + (0x10000 - 0x100));
  742. goto inside;
  743. do {
  744. faddr -= 0x100;
  745. inside:
  746. __asm__ __volatile__("sta %%g0, [%0] %1nt"
  747.      "sta %%g0, [%0 + %2] %1nt"
  748.      "sta %%g0, [%0 + %3] %1nt"
  749.      "sta %%g0, [%0 + %4] %1nt"
  750.      "sta %%g0, [%0 + %5] %1nt"
  751.      "sta %%g0, [%0 + %6] %1nt"
  752.      "sta %%g0, [%0 + %7] %1nt"
  753.      "sta %%g0, [%0 + %8] %1nt" : :
  754.      "r" (faddr),
  755.      "i" (ASI_M_FLUSH_SEG),
  756.      "r" (a), "r" (b), "r" (c), "r" (d),
  757.      "r" (e), "r" (f), "r" (g));
  758. } while (faddr != start);
  759. start += SRMMU_PMD_SIZE;
  760. }
  761. srmmu_set_context(octx);
  762. __restore_flags(flags);
  763. FLUSH_END
  764. }
  766. static void cypress_flush_cache_page(struct vm_area_struct *vma, unsigned long page)
  767. {
  768. register unsigned long a, b, c, d, e, f, g;
  769. struct mm_struct *mm = vma->vm_mm;
  770. unsigned long flags, line;
  771. int octx;
  773. FLUSH_BEGIN(mm)
  774. flush_user_windows();
  775. __save_and_cli(flags);
  776. octx = srmmu_get_context();
  777. srmmu_set_context(mm->context);
  778. a = 0x20; b = 0x40; c = 0x60;
  779. d = 0x80; e = 0xa0; f = 0xc0; g = 0xe0;
  781. page &= PAGE_MASK;
  782. line = (page + PAGE_SIZE) - 0x100;
  783. goto inside;
  784. do {
  785. line -= 0x100;
  786. inside:
  787. __asm__ __volatile__("sta %%g0, [%0] %1nt"
  788.      "sta %%g0, [%0 + %2] %1nt"
  789.      "sta %%g0, [%0 + %3] %1nt"
  790.      "sta %%g0, [%0 + %4] %1nt"
  791.      "sta %%g0, [%0 + %5] %1nt"
  792.      "sta %%g0, [%0 + %6] %1nt"
  793.      "sta %%g0, [%0 + %7] %1nt"
  794.      "sta %%g0, [%0 + %8] %1nt" : :
  795.      "r" (line),
  796.      "i" (ASI_M_FLUSH_PAGE),
  797.      "r" (a), "r" (b), "r" (c), "r" (d),
  798.      "r" (e), "r" (f), "r" (g));
  799. } while(line != page);
  800. srmmu_set_context(octx);
  801. __restore_flags(flags);
  802. FLUSH_END
  803. }
  805. /* Cypress is copy-back, at least that is how we configure it. */
  806. static void cypress_flush_page_to_ram(unsigned long page)
  807. {
  808. register unsigned long a, b, c, d, e, f, g;
  809. unsigned long line;
  811. a = 0x20; b = 0x40; c = 0x60; d = 0x80; e = 0xa0; f = 0xc0; g = 0xe0;
  812. page &= PAGE_MASK;
  813. line = (page + PAGE_SIZE) - 0x100;
  814. goto inside;
  815. do {
  816. line -= 0x100;
  817. inside:
  818. __asm__ __volatile__("sta %%g0, [%0] %1nt"
  819.      "sta %%g0, [%0 + %2] %1nt"
  820.      "sta %%g0, [%0 + %3] %1nt"
  821.      "sta %%g0, [%0 + %4] %1nt"
  822.      "sta %%g0, [%0 + %5] %1nt"
  823.      "sta %%g0, [%0 + %6] %1nt"
  824.      "sta %%g0, [%0 + %7] %1nt"
  825.      "sta %%g0, [%0 + %8] %1nt" : :
  826.      "r" (line),
  827.      "i" (ASI_M_FLUSH_PAGE),
  828.      "r" (a), "r" (b), "r" (c), "r" (d),
  829.      "r" (e), "r" (f), "r" (g));
  830. } while(line != page);
  831. }
  833. /* Cypress is also IO cache coherent. */
  834. static void cypress_flush_page_for_dma(unsigned long page)
  835. {
  836. }
  838. /* Cypress has unified L2 VIPT, from which both instructions and data
  839.  * are stored.  It does not have an onboard icache of any sort, therefore
  840.  * no flush is necessary.
  841.  */
  842. static void cypress_flush_sig_insns(struct mm_struct *mm, unsigned long insn_addr)
  843. {
  844. }
  846. static void cypress_flush_tlb_all(void)
  847. {
  848. srmmu_flush_whole_tlb();
  849. }
  851. static void cypress_flush_tlb_mm(struct mm_struct *mm)
  852. {
  853. FLUSH_BEGIN(mm)
  854. __asm__ __volatile__(
  855. "lda [%0] %3, %%g5nt"
  856. "sta %2, [%0] %3nt"
  857. "sta %%g0, [%1] %4nt"
  858. "sta %%g5, [%0] %3n"
  859. : /* no outputs */
  860. : "r" (SRMMU_CTX_REG), "r" (0x300), "r" (mm->context),
  861.   "i" (ASI_M_MMUREGS), "i" (ASI_M_FLUSH_PROBE)
  862. : "g5");
  863. FLUSH_END
  864. }
  866. static void cypress_flush_tlb_range(struct mm_struct *mm, unsigned long start, unsigned long end)
  867. {
  868. unsigned long size;
  870. FLUSH_BEGIN(mm)
  871. start &= SRMMU_PGDIR_MASK;
  872. size = SRMMU_PGDIR_ALIGN(end) - start;
  873. __asm__ __volatile__(
  874. "lda [%0] %5, %%g5nt"
  875. "sta %1, [%0] %5n"
  876. "1:nt"
  877. "subcc %3, %4, %3nt"
  878. "bne 1bnt"
  879. " sta %%g0, [%2 + %3] %6nt"
  880. "sta %%g5, [%0] %5n"
  881. : /* no outputs */
  882. : "r" (SRMMU_CTX_REG), "r" (mm->context), "r" (start | 0x200),
  883.   "r" (size), "r" (SRMMU_PGDIR_SIZE), "i" (ASI_M_MMUREGS),
  884.   "i" (ASI_M_FLUSH_PROBE)
  885. : "g5", "cc");
  886. FLUSH_END
  887. }
  889. static void cypress_flush_tlb_page(struct vm_area_struct *vma, unsigned long page)
  890. {
  891. struct mm_struct *mm = vma->vm_mm;
  893. FLUSH_BEGIN(mm)
  894. __asm__ __volatile__(
  895. "lda [%0] %3, %%g5nt"
  896. "sta %1, [%0] %3nt"
  897. "sta %%g0, [%2] %4nt"
  898. "sta %%g5, [%0] %3n"
  899. : /* no outputs */
  900. : "r" (SRMMU_CTX_REG), "r" (mm->context), "r" (page & PAGE_MASK),
  901.   "i" (ASI_M_MMUREGS), "i" (ASI_M_FLUSH_PROBE)
  902. : "g5");
  903. FLUSH_END
  904. }
  906. /* viking.S */
  907. extern void viking_flush_cache_all(void);
  908. extern void viking_flush_cache_mm(struct mm_struct *mm);
  909. extern void viking_flush_cache_range(struct mm_struct *mm, unsigned long start,
  910.      unsigned long end);
  911. extern void viking_flush_cache_page(struct vm_area_struct *vma,
  912.     unsigned long page);
  913. extern void viking_flush_page_to_ram(unsigned long page);
  914. extern void viking_flush_page_for_dma(unsigned long page);
  915. extern void viking_flush_sig_insns(struct mm_struct *mm, unsigned long addr);
  916. extern void viking_flush_page(unsigned long page);
  917. extern void viking_mxcc_flush_page(unsigned long page);
  918. extern void viking_flush_tlb_all(void);
  919. extern void viking_flush_tlb_mm(struct mm_struct *mm);
  920. extern void viking_flush_tlb_range(struct mm_struct *mm, unsigned long start,
  921.    unsigned long end);
  922. extern void viking_flush_tlb_page(struct vm_area_struct *vma,
  923.   unsigned long page);
  924. extern void sun4dsmp_flush_tlb_all(void);
  925. extern void sun4dsmp_flush_tlb_mm(struct mm_struct *mm);
  926. extern void sun4dsmp_flush_tlb_range(struct mm_struct *mm, unsigned long start,
  927.    unsigned long end);
  928. extern void sun4dsmp_flush_tlb_page(struct vm_area_struct *vma,
  929.   unsigned long page);
  931. /* hypersparc.S */
  932. extern void hypersparc_flush_cache_all(void);
  933. extern void hypersparc_flush_cache_mm(struct mm_struct *mm);
  934. extern void hypersparc_flush_cache_range(struct mm_struct *mm, unsigned long start, unsigned long end);
  935. extern void hypersparc_flush_cache_page(struct vm_area_struct *vma, unsigned long page);
  936. extern void hypersparc_flush_page_to_ram(unsigned long page);
  937. extern void hypersparc_flush_page_for_dma(unsigned long page);
  938. extern void hypersparc_flush_sig_insns(struct mm_struct *mm, unsigned long insn_addr);
  939. extern void hypersparc_flush_tlb_all(void);
  940. extern void hypersparc_flush_tlb_mm(struct mm_struct *mm);
  941. extern void hypersparc_flush_tlb_range(struct mm_struct *mm, unsigned long start, unsigned long end);
  942. extern void hypersparc_flush_tlb_page(struct vm_area_struct *vma, unsigned long page);
  943. extern void hypersparc_setup_blockops(void);
  945. /*
  946.  * NOTE: All of this startup code assumes the low 16mb (approx.) of
  947.  *       kernel mappings are done with one single contiguous chunk of
  948.  *       ram.  On small ram machines (classics mainly) we only get
  949.  *       around 8mb mapped for us.
  950.  */
  952. void __init early_pgtable_allocfail(char *type)
  953. {
  954. prom_printf("inherit_prom_mappings: Cannot alloc kernel %s.n", type);
  955. prom_halt();
  956. }
  958. void __init srmmu_early_allocate_ptable_skeleton(unsigned long start, unsigned long end)
  959. {
  960. pgd_t *pgdp;
  961. pmd_t *pmdp;
  962. pte_t *ptep;
  964. while(start < end) {
  965. pgdp = pgd_offset_k(start);
  966. if(srmmu_pgd_none(*(pgd_t *)__nocache_fix(pgdp))) {
  967. pmdp = (pmd_t *)__srmmu_get_nocache(SRMMU_PMD_TABLE_SIZE, SRMMU_PMD_TABLE_SIZE);
  968. if (pmdp == NULL)
  969. early_pgtable_allocfail("pmd");
  970. memset(__nocache_fix(pmdp), 0, SRMMU_PMD_TABLE_SIZE);
  971. srmmu_pgd_set(__nocache_fix(pgdp), pmdp);
  972. }
  973. pmdp = srmmu_pmd_offset(__nocache_fix(pgdp), start);
  974. if(srmmu_pmd_none(*(pmd_t *)__nocache_fix(pmdp))) {
  975. ptep = (pte_t *)__srmmu_get_nocache(SRMMU_PTE_TABLE_SIZE, SRMMU_PTE_TABLE_SIZE);
  976. if (ptep == NULL)
  977. early_pgtable_allocfail("pte");
  978. memset(__nocache_fix(ptep), 0, SRMMU_PTE_TABLE_SIZE);
  979. srmmu_pmd_set(__nocache_fix(pmdp), ptep);
  980. }
  981. start = (start + SRMMU_PMD_SIZE) & SRMMU_PMD_MASK;
  982. }
  983. }
  985. void __init srmmu_allocate_ptable_skeleton(unsigned long start, unsigned long end)
  986. {
  987. pgd_t *pgdp;
  988. pmd_t *pmdp;
  989. pte_t *ptep;
  991. while(start < end) {
  992. pgdp = pgd_offset_k(start);
  993. if(srmmu_pgd_none(*pgdp)) {
  994. pmdp = (pmd_t *)__srmmu_get_nocache(SRMMU_PMD_TABLE_SIZE, SRMMU_PMD_TABLE_SIZE);
  995. if (pmdp == NULL)
  996. early_pgtable_allocfail("pmd");
  997. memset(pmdp, 0, SRMMU_PMD_TABLE_SIZE);
  998. srmmu_pgd_set(pgdp, pmdp);
  999. }
  1000. pmdp = srmmu_pmd_offset(pgdp, start);
  1001. if(srmmu_pmd_none(*pmdp)) {
  1002. ptep = (pte_t *)__srmmu_get_nocache(SRMMU_PTE_TABLE_SIZE, SRMMU_PTE_TABLE_SIZE);
  1003. if (ptep == NULL)
  1004. early_pgtable_allocfail("pte");
  1005. memset(ptep, 0, SRMMU_PTE_TABLE_SIZE);
  1006. srmmu_pmd_set(pmdp, ptep);
  1007. }
  1008. start = (start + SRMMU_PMD_SIZE) & SRMMU_PMD_MASK;
  1009. }
  1010. }
  1012. /*
  1013.  * This is much cleaner than poking around physical address space
  1014.  * looking at the prom's page table directly which is what most
  1015.  * other OS's do.  Yuck... this is much better.
  1016.  */
  1017. void __init srmmu_inherit_prom_mappings(unsigned long start,unsigned long end)
  1018. {
  1019. pgd_t *pgdp;
  1020. pmd_t *pmdp;
  1021. pte_t *ptep;
  1022. int what = 0; /* 0 = normal-pte, 1 = pmd-level pte, 2 = pgd-level pte */
  1023. unsigned long prompte;
  1025. while(start <= end) {
  1026. if (start == 0)
  1027. break; /* probably wrap around */
  1028. if(start == 0xfef00000)
  1029. start = KADB_DEBUGGER_BEGVM;
  1030. if(!(prompte = srmmu_hwprobe(start))) {
  1031. start += PAGE_SIZE;
  1032. continue;
  1033. }
  1034.     
  1035. /* A red snapper, see what it really is. */
  1036. what = 0;
  1037.     
  1038. if(!(start & ~(SRMMU_PMD_MASK))) {
  1039. if(srmmu_hwprobe((start-PAGE_SIZE) + SRMMU_PMD_SIZE) == prompte)
  1040. what = 1;
  1041. }
  1042.     
  1043. if(!(start & ~(SRMMU_PGDIR_MASK))) {
  1044. if(srmmu_hwprobe((start-PAGE_SIZE) + SRMMU_PGDIR_SIZE) ==
  1045.    prompte)
  1046. what = 2;
  1047. }
  1048.     
  1049. pgdp = pgd_offset_k(start);
  1050. if(what == 2) {
  1051. *(pgd_t *)__nocache_fix(pgdp) = __pgd(prompte);
  1052. start += SRMMU_PGDIR_SIZE;
  1053. continue;
  1054. }
  1055. if(srmmu_pgd_none(*(pgd_t *)__nocache_fix(pgdp))) {
  1056. pmdp = (pmd_t *)__srmmu_get_nocache(SRMMU_PMD_TABLE_SIZE, SRMMU_PMD_TABLE_SIZE);
  1057. if (pmdp == NULL)
  1058. early_pgtable_allocfail("pmd");
  1059. memset(__nocache_fix(pmdp), 0, SRMMU_PMD_TABLE_SIZE);
  1060. srmmu_pgd_set(__nocache_fix(pgdp), pmdp);
  1061. }
  1062. pmdp = srmmu_pmd_offset(__nocache_fix(pgdp), start);
  1063. if(what == 1) {
  1064. *(pmd_t *)__nocache_fix(pmdp) = __pmd(prompte);
  1065. start += SRMMU_PMD_SIZE;
  1066. continue;
  1067. }
  1068. if(srmmu_pmd_none(*(pmd_t *)__nocache_fix(pmdp))) {
  1069. ptep = (pte_t *)__srmmu_get_nocache(SRMMU_PTE_TABLE_SIZE, SRMMU_PTE_TABLE_SIZE);
  1070. if (ptep == NULL)
  1071. early_pgtable_allocfail("pte");
  1072. memset(__nocache_fix(ptep), 0, SRMMU_PTE_TABLE_SIZE);
  1073. srmmu_pmd_set(__nocache_fix(pmdp), ptep);
  1074. }
  1075. ptep = srmmu_pte_offset(__nocache_fix(pmdp), start);
  1076. *(pte_t *)__nocache_fix(ptep) = __pte(prompte);
  1077. start += PAGE_SIZE;
  1078. }
  1079. }
  1081. #define KERNEL_PTE(page_shifted) ((page_shifted)|SRMMU_CACHE|SRMMU_PRIV|SRMMU_VALID)
  1083. /* Create a third-level SRMMU 16MB page mapping. */
  1084. static void __init do_large_mapping(unsigned long vaddr, unsigned long phys_base)
  1085. {
  1086. pgd_t *pgdp = pgd_offset_k(vaddr);
  1087. unsigned long big_pte;
  1089. big_pte = KERNEL_PTE(phys_base >> 4);
  1090. *(pgd_t *)__nocache_fix(pgdp) = __pgd(big_pte);
  1091. }
  1093. /* Map sp_bank entry SP_ENTRY, starting at virtual address VBASE. */
  1094. static unsigned long __init map_spbank(unsigned long vbase, int sp_entry)
  1095. {
  1096. unsigned long pstart = (sp_banks[sp_entry].base_addr & SRMMU_PGDIR_MASK);
  1097. unsigned long vstart = (vbase & SRMMU_PGDIR_MASK);
  1098. unsigned long vend = SRMMU_PGDIR_ALIGN(vbase + sp_banks[sp_entry].num_bytes);
  1099. /* Map "low" memory only */
  1100. const unsigned long min_vaddr = PAGE_OFFSET;
  1101. const unsigned long max_vaddr = PAGE_OFFSET + SRMMU_MAXMEM;
  1103. if (vstart < min_vaddr || vstart >= max_vaddr)
  1104. return vstart;
  1106. if (vend > max_vaddr || vend < min_vaddr)
  1107. vend = max_vaddr;
  1109. while(vstart < vend) {
  1110. do_large_mapping(vstart, pstart);
  1111. vstart += SRMMU_PGDIR_SIZE; pstart += SRMMU_PGDIR_SIZE;
  1112. }
  1113. return vstart;
  1114. }
  1116. static inline void memprobe_error(char *msg)
  1117. {
  1118. prom_printf(msg);
  1119. prom_printf("Halting now...n");
  1120. prom_halt();
  1121. }
  1123. static inline void map_kernel(void)
  1124. {
  1125. int i;
  1127. if (phys_base > 0) {
  1128. do_large_mapping(PAGE_OFFSET, phys_base);
  1129. }
  1131. for (i = 0; sp_banks[i].num_bytes != 0; i++) {
  1132. map_spbank((unsigned long)__va(sp_banks[i].base_addr), i);
  1133. }
  1135. BTFIXUPSET_SIMM13(user_ptrs_per_pgd, PAGE_OFFSET / SRMMU_PGDIR_SIZE);
  1136. }
  1138. /* Paging initialization on the Sparc Reference MMU. */
  1139. extern void sparc_context_init(int);
  1141. extern int linux_num_cpus;
  1142. extern unsigned long totalhigh_pages;
  1144. void (*poke_srmmu)(void) __initdata = NULL;
  1146. extern unsigned long bootmem_init(unsigned long *pages_avail);
  1147. extern void sun_serial_setup(void);
  1149. void __init srmmu_paging_init(void)
  1150. {
  1151. int i, cpunode;
  1152. char node_str[128];
  1153. pgd_t *pgd;
  1154. pmd_t *pmd;
  1155. pte_t *pte;
  1156. unsigned long pages_avail;
  1158. sparc_iomap.start = SUN4M_IOBASE_VADDR; /* 16MB of IOSPACE on all sun4m's. */
  1160. if (sparc_cpu_model == sun4d)
  1161. num_contexts = 65536; /* We know it is Viking */
  1162. else {
  1163. /* Find the number of contexts on the srmmu. */
  1164. cpunode = prom_getchild(prom_root_node);
  1165. num_contexts = 0;
  1166. while(cpunode != 0) {
  1167. prom_getstring(cpunode, "device_type", node_str, sizeof(node_str));
  1168. if(!strcmp(node_str, "cpu")) {
  1169. num_contexts = prom_getintdefault(cpunode, "mmu-nctx", 0x8);
  1170. break;
  1171. }
  1172. cpunode = prom_getsibling(cpunode);
  1173. }
  1174. }
  1176. if(!num_contexts) {
  1177. prom_printf("Something wrong, can't find cpu node in paging_init.n");
  1178. prom_halt();
  1179. }
  1181. pages_avail = 0;
  1182. last_valid_pfn = bootmem_init(&pages_avail);
  1184. srmmu_nocache_calcsize();
  1185. srmmu_nocache_init();
  1186.         srmmu_inherit_prom_mappings(0xfe400000,(LINUX_OPPROM_ENDVM-PAGE_SIZE));
  1187. map_kernel();
  1189. /* ctx table has to be physically aligned to its size */
  1190. srmmu_context_table = (ctxd_t *)__srmmu_get_nocache(num_contexts*sizeof(ctxd_t), num_contexts*sizeof(ctxd_t));
  1191. srmmu_ctx_table_phys = (ctxd_t *)__nocache_pa((unsigned long)srmmu_context_table);
  1193. for(i = 0; i < num_contexts; i++)
  1194. srmmu_ctxd_set((ctxd_t *)__nocache_fix(&srmmu_context_table[i]), srmmu_swapper_pg_dir);
  1196. flush_cache_all();
  1197. srmmu_set_ctable_ptr((unsigned long)srmmu_ctx_table_phys);
  1198. flush_tlb_all();
  1199. poke_srmmu();
  1201. #if CONFIG_SUN_IO
  1202. srmmu_allocate_ptable_skeleton(sparc_iomap.start, IOBASE_END);
  1203. srmmu_allocate_ptable_skeleton(DVMA_VADDR, DVMA_END);
  1204. #endif
  1206. srmmu_allocate_ptable_skeleton(fix_kmap_begin, fix_kmap_end);
  1207. srmmu_allocate_ptable_skeleton(pkmap_base, pkmap_base_end);
  1209. pgd = pgd_offset_k(pkmap_base);
  1210. pmd = pmd_offset(pgd, pkmap_base);
  1211. pte = pte_offset(pmd, pkmap_base);
  1212. pkmap_page_table = pte;
  1214. flush_cache_all();
  1215. flush_tlb_all();
  1217. /*
  1218.  * This does not logically belong here, but we need to
  1219.  * call it at the moment we are able to use the bootmem
  1220.  * allocator.
  1221.  */
  1222. sun_serial_setup();
  1224. sparc_context_init(num_contexts);
  1226. kmap_init();
  1228. {
  1229. unsigned long zones_size[MAX_NR_ZONES];
  1230. unsigned long zholes_size[MAX_NR_ZONES];
  1231. unsigned long npages;
  1232. int znum;
  1234. for (znum = 0; znum < MAX_NR_ZONES; znum++)
  1235. zones_size[znum] = zholes_size[znum] = 0;
  1237. npages = max_low_pfn - (phys_base >> PAGE_SHIFT);
  1239. zones_size[ZONE_DMA] = npages;
  1240. zholes_size[ZONE_DMA] = npages - pages_avail;
  1242. npages = highend_pfn - max_low_pfn;
  1243. zones_size[ZONE_HIGHMEM] = npages;
  1244. zholes_size[ZONE_HIGHMEM] = npages - calc_highpages();
  1246. free_area_init_node(0, NULL, NULL, zones_size,
  1247.     phys_base, zholes_size);
  1248. }
  1249. }
  1251. static void srmmu_mmu_info(struct seq_file *m)
  1252. {
  1253. seq_printf(m, 
  1254.    "MMU typet: %sn"
  1255.    "contextst: %dn"
  1256.    "nocache totalt: %ldn"
  1257.    "nocache usedt: %dn",
  1258.    srmmu_name,
  1259.    num_contexts,
  1260.    srmmu_nocache_size,
  1261.    (srmmu_nocache_used << SRMMU_NOCACHE_BITMAP_SHIFT));
  1262. }
  1264. static void srmmu_update_mmu_cache(struct vm_area_struct * vma, unsigned long address, pte_t pte)
  1265. {
  1266. }
  1268. static void srmmu_destroy_context(struct mm_struct *mm)
  1269. {
  1271. if(mm->context != NO_CONTEXT) {
  1272. flush_cache_mm(mm);
  1273. srmmu_ctxd_set(&srmmu_context_table[mm->context], srmmu_swapper_pg_dir);
  1274. flush_tlb_mm(mm);
  1275. spin_lock(&srmmu_context_spinlock);
  1276. free_context(mm->context);
  1277. spin_unlock(&srmmu_context_spinlock);
  1278. mm->context = NO_CONTEXT;
  1279. }
  1280. }
  1282. /* Init various srmmu chip types. */
  1283. static void __init srmmu_is_bad(void)
  1284. {
  1285. prom_printf("Could not determine SRMMU chip type.n");
  1286. prom_halt();
  1287. }
  1289. static void __init init_vac_layout(void)
  1290. {
  1291. int nd, cache_lines;
  1292. char node_str[128];
  1293. #ifdef CONFIG_SMP
  1294. int cpu = 0;
  1295. unsigned long max_size = 0;
  1296. unsigned long min_line_size = 0x10000000;
  1297. #endif
  1299. nd = prom_getchild(prom_root_node);
  1300. while((nd = prom_getsibling(nd)) != 0) {
  1301. prom_getstring(nd, "device_type", node_str, sizeof(node_str));
  1302. if(!strcmp(node_str, "cpu")) {
  1303. vac_line_size = prom_getint(nd, "cache-line-size");
  1304. if (vac_line_size == -1) {
  1305. prom_printf("can't determine cache-line-size, "
  1306.     "halting.n");
  1307. prom_halt();
  1308. }
  1309. cache_lines = prom_getint(nd, "cache-nlines");
  1310. if (cache_lines == -1) {
  1311. prom_printf("can't determine cache-nlines, halting.n");
  1312. prom_halt();
  1313. }
  1315. vac_cache_size = cache_lines * vac_line_size;
  1316. #ifdef CONFIG_SMP
  1317. if(vac_cache_size > max_size)
  1318. max_size = vac_cache_size;
  1319. if(vac_line_size < min_line_size)
  1320. min_line_size = vac_line_size;
  1321. cpu++;
  1322. if(cpu == smp_num_cpus)
  1323. break;
  1324. #else
  1325. break;
  1326. #endif
  1327. }
  1328. }
  1329. if(nd == 0) {
  1330. prom_printf("No CPU nodes found, halting.n");
  1331. prom_halt();
  1332. }
  1333. #ifdef CONFIG_SMP
  1334. vac_cache_size = max_size;
  1335. vac_line_size = min_line_size;
  1336. #endif
  1337. printk("SRMMU: Using VAC size of %d bytes, line size %d bytes.n",
  1338.        (int)vac_cache_size, (int)vac_line_size);
  1339. }
  1341. static void __init poke_hypersparc(void)
  1342. {
  1343. volatile unsigned long clear;
  1344. unsigned long mreg = srmmu_get_mmureg();
  1346. hyper_flush_unconditional_combined();
  1348. mreg &= ~(HYPERSPARC_CWENABLE);
  1349. mreg |= (HYPERSPARC_CENABLE | HYPERSPARC_WBENABLE);
  1350. mreg |= (HYPERSPARC_CMODE);
  1352. srmmu_set_mmureg(mreg);
  1354. #if 0 /* XXX I think this is bad news... -DaveM */
  1355. hyper_clear_all_tags();
  1356. #endif
  1358. put_ross_icr(HYPERSPARC_ICCR_FTD | HYPERSPARC_ICCR_ICE);
  1359. hyper_flush_whole_icache();
  1360. clear = srmmu_get_faddr();
  1361. clear = srmmu_get_fstatus();
  1362. }
  1364. static void __init init_hypersparc(void)
  1365. {
  1366. srmmu_name = "ROSS HyperSparc";
  1368. init_vac_layout();
  1370. is_hypersparc = 1;
  1372. BTFIXUPSET_CALL(pte_clear, srmmu_pte_clear, BTFIXUPCALL_NORM);
  1373. BTFIXUPSET_CALL(pmd_clear, srmmu_pmd_clear, BTFIXUPCALL_NORM);
  1374. BTFIXUPSET_CALL(pgd_clear, srmmu_pgd_clear, BTFIXUPCALL_NORM);
  1375. BTFIXUPSET_CALL(flush_cache_all, hypersparc_flush_cache_all, BTFIXUPCALL_NORM);
  1376. BTFIXUPSET_CALL(flush_cache_mm, hypersparc_flush_cache_mm, BTFIXUPCALL_NORM);
  1377. BTFIXUPSET_CALL(flush_cache_range, hypersparc_flush_cache_range, BTFIXUPCALL_NORM);
  1378. BTFIXUPSET_CALL(flush_cache_page, hypersparc_flush_cache_page, BTFIXUPCALL_NORM);
  1380. BTFIXUPSET_CALL(flush_tlb_all, hypersparc_flush_tlb_all, BTFIXUPCALL_NORM);
  1381. BTFIXUPSET_CALL(flush_tlb_mm, hypersparc_flush_tlb_mm, BTFIXUPCALL_NORM);
  1382. BTFIXUPSET_CALL(flush_tlb_range, hypersparc_flush_tlb_range, BTFIXUPCALL_NORM);
  1383. BTFIXUPSET_CALL(flush_tlb_page, hypersparc_flush_tlb_page, BTFIXUPCALL_NORM);
  1385. BTFIXUPSET_CALL(__flush_page_to_ram, hypersparc_flush_page_to_ram, BTFIXUPCALL_NORM);
  1386. BTFIXUPSET_CALL(flush_sig_insns, hypersparc_flush_sig_insns, BTFIXUPCALL_NORM);
  1387. BTFIXUPSET_CALL(flush_page_for_dma, hypersparc_flush_page_for_dma, BTFIXUPCALL_NOP);
  1390. poke_srmmu = poke_hypersparc;
  1392. hypersparc_setup_blockops();
  1393. }
  1395. static void __init poke_cypress(void)
  1396. {
  1397. unsigned long mreg = srmmu_get_mmureg();
  1398. unsigned long faddr, tagval;
  1399. volatile unsigned long cypress_sucks;
  1400. volatile unsigned long clear;
  1402. clear = srmmu_get_faddr();
  1403. clear = srmmu_get_fstatus();
  1405. if (!(mreg & CYPRESS_CENABLE)) {
  1406. for(faddr = 0x0; faddr < 0x10000; faddr += 20) {
  1407. __asm__ __volatile__("sta %%g0, [%0 + %1] %2nt"
  1408.      "sta %%g0, [%0] %2nt" : :
  1409.      "r" (faddr), "r" (0x40000),
  1410.      "i" (ASI_M_DATAC_TAG));
  1411. }
  1412. } else {
  1413. for(faddr = 0; faddr < 0x10000; faddr += 0x20) {
  1414. __asm__ __volatile__("lda [%1 + %2] %3, %0nt" :
  1415.      "=r" (tagval) :
  1416.      "r" (faddr), "r" (0x40000),
  1417.      "i" (ASI_M_DATAC_TAG));
  1419. /* If modified and valid, kick it. */
  1420. if((tagval & 0x60) == 0x60)
  1421. cypress_sucks = *(unsigned long *)
  1422. (0xf0020000 + faddr);
  1423. }
  1424. }
  1426. /* And one more, for our good neighbor, Mr. Broken Cypress. */
  1427. clear = srmmu_get_faddr();
  1428. clear = srmmu_get_fstatus();
  1430. mreg |= (CYPRESS_CENABLE | CYPRESS_CMODE);
  1431. srmmu_set_mmureg(mreg);
  1432. }
  1434. static void __init init_cypress_common(void)
  1435. {
  1436. init_vac_layout();
  1438. BTFIXUPSET_CALL(pte_clear, srmmu_pte_clear, BTFIXUPCALL_NORM);
  1439. BTFIXUPSET_CALL(pmd_clear, srmmu_pmd_clear, BTFIXUPCALL_NORM);
  1440. BTFIXUPSET_CALL(pgd_clear, srmmu_pgd_clear, BTFIXUPCALL_NORM);
  1441. BTFIXUPSET_CALL(flush_cache_all, cypress_flush_cache_all, BTFIXUPCALL_NORM);
  1442. BTFIXUPSET_CALL(flush_cache_mm, cypress_flush_cache_mm, BTFIXUPCALL_NORM);
  1443. BTFIXUPSET_CALL(flush_cache_range, cypress_flush_cache_range, BTFIXUPCALL_NORM);
  1444. BTFIXUPSET_CALL(flush_cache_page, cypress_flush_cache_page, BTFIXUPCALL_NORM);
  1446. BTFIXUPSET_CALL(flush_tlb_all, cypress_flush_tlb_all, BTFIXUPCALL_NORM);
  1447. BTFIXUPSET_CALL(flush_tlb_mm, cypress_flush_tlb_mm, BTFIXUPCALL_NORM);
  1448. BTFIXUPSET_CALL(flush_tlb_page, cypress_flush_tlb_page, BTFIXUPCALL_NORM);
  1449. BTFIXUPSET_CALL(flush_tlb_range, cypress_flush_tlb_range, BTFIXUPCALL_NORM);
  1452. BTFIXUPSET_CALL(__flush_page_to_ram, cypress_flush_page_to_ram, BTFIXUPCALL_NORM);
  1453. BTFIXUPSET_CALL(flush_sig_insns, cypress_flush_sig_insns, BTFIXUPCALL_NOP);
  1454. BTFIXUPSET_CALL(flush_page_for_dma, cypress_flush_page_for_dma, BTFIXUPCALL_NOP);
  1456. poke_srmmu = poke_cypress;
  1457. }
  1459. static void __init init_cypress_604(void)
  1460. {
  1461. srmmu_name = "ROSS Cypress-604(UP)";
  1462. srmmu_modtype = Cypress;
  1463. init_cypress_common();
  1464. }
  1466. static void __init init_cypress_605(unsigned long mrev)
  1467. {
  1468. srmmu_name = "ROSS Cypress-605(MP)";
  1469. if(mrev == 0xe) {
  1470. srmmu_modtype = Cypress_vE;
  1471. hwbug_bitmask |= HWBUG_COPYBACK_BROKEN;
  1472. } else {
  1473. if(mrev == 0xd) {
  1474. srmmu_modtype = Cypress_vD;
  1475. hwbug_bitmask |= HWBUG_ASIFLUSH_BROKEN;
  1476. } else {
  1477. srmmu_modtype = Cypress;
  1478. }
  1479. }
  1480. init_cypress_common();
  1481. }
  1483. static void __init poke_swift(void)
  1484. {
  1485. unsigned long mreg;
  1487. /* Clear any crap from the cache or else... */
  1488. swift_flush_cache_all();
  1490. /* Enable I & D caches */
  1491. mreg = srmmu_get_mmureg();
  1492. mreg |= (SWIFT_IE | SWIFT_DE);
  1493. /*
  1494.  * The Swift branch folding logic is completely broken.  At
  1495.  * trap time, if things are just right, if can mistakenly
  1496.  * think that a trap is coming from kernel mode when in fact
  1497.  * it is coming from user mode (it mis-executes the branch in
  1498.  * the trap code).  So you see things like crashme completely
  1499.  * hosing your machine which is completely unacceptable.  Turn
  1500.  * this shit off... nice job Fujitsu.
  1501.  */
  1502. mreg &= ~(SWIFT_BF);
  1503. srmmu_set_mmureg(mreg);
  1504. }
  1506. #define SWIFT_MASKID_ADDR  0x10003018
  1507. static void __init init_swift(void)
  1508. {
  1509. unsigned long swift_rev;
  1511. __asm__ __volatile__("lda [%1] %2, %0nt"
  1512.      "srl %0, 0x18, %0nt" :
  1513.      "=r" (swift_rev) :
  1514.      "r" (SWIFT_MASKID_ADDR), "i" (ASI_M_BYPASS));
  1515. srmmu_name = "Fujitsu Swift";
  1516. switch(swift_rev) {
  1517. case 0x11:
  1518. case 0x20:
  1519. case 0x23:
  1520. case 0x30:
  1521. srmmu_modtype = Swift_lots_o_bugs;
  1522. hwbug_bitmask |= (HWBUG_KERN_ACCBROKEN | HWBUG_KERN_CBITBROKEN);
  1523. /*
  1524.  * Gee george, I wonder why Sun is so hush hush about
  1525.  * this hardware bug... really braindamage stuff going
  1526.  * on here.  However I think we can find a way to avoid
  1527.  * all of the workaround overhead under Linux.  Basically,
  1528.  * any page fault can cause kernel pages to become user
  1529.  * accessible (the mmu gets confused and clears some of
  1530.  * the ACC bits in kernel ptes).  Aha, sounds pretty
  1531.  * horrible eh?  But wait, after extensive testing it appears
  1532.  * that if you use pgd_t level large kernel pte's (like the
  1533.  * 4MB pages on the Pentium) the bug does not get tripped
  1534.  * at all.  This avoids almost all of the major overhead.
  1535.  * Welcome to a world where your vendor tells you to,
  1536.  * "apply this kernel patch" instead of "sorry for the
  1537.  * broken hardware, send it back and we'll give you
  1538.  * properly functioning parts"
  1539.  */
  1540. break;
  1541. case 0x25:
  1542. case 0x31:
  1543. srmmu_modtype = Swift_bad_c;
  1544. hwbug_bitmask |= HWBUG_KERN_CBITBROKEN;
  1545. /*
  1546.  * You see Sun allude to this hardware bug but never
  1547.  * admit things directly, they'll say things like,
  1548.  * "the Swift chip cache problems" or similar.
  1549.  */
  1550. break;
  1551. default:
  1552. srmmu_modtype = Swift_ok;
  1553. break;
  1554. };
  1556. BTFIXUPSET_CALL(flush_cache_all, swift_flush_cache_all, BTFIXUPCALL_NORM);
  1557. BTFIXUPSET_CALL(flush_cache_mm, swift_flush_cache_mm, BTFIXUPCALL_NORM);
  1558. BTFIXUPSET_CALL(flush_cache_page, swift_flush_cache_page, BTFIXUPCALL_NORM);
  1559. BTFIXUPSET_CALL(flush_cache_range, swift_flush_cache_range, BTFIXUPCALL_NORM);
  1562. BTFIXUPSET_CALL(flush_tlb_all, swift_flush_tlb_all, BTFIXUPCALL_NORM);
  1563. BTFIXUPSET_CALL(flush_tlb_mm, swift_flush_tlb_mm, BTFIXUPCALL_NORM);
  1564. BTFIXUPSET_CALL(flush_tlb_page, swift_flush_tlb_page, BTFIXUPCALL_NORM);
  1565. BTFIXUPSET_CALL(flush_tlb_range, swift_flush_tlb_range, BTFIXUPCALL_NORM);
  1567. BTFIXUPSET_CALL(__flush_page_to_ram, swift_flush_page_to_ram, BTFIXUPCALL_NORM);
  1568. BTFIXUPSET_CALL(flush_sig_insns, swift_flush_sig_insns, BTFIXUPCALL_NORM);
  1569. BTFIXUPSET_CALL(flush_page_for_dma, swift_flush_page_for_dma, BTFIXUPCALL_NORM);
  1571. BTFIXUPSET_CALL(update_mmu_cache, swift_update_mmu_cache, BTFIXUPCALL_NORM);
  1573. flush_page_for_dma_global = 0;
  1575. /*
  1576.  * Are you now convinced that the Swift is one of the
  1577.  * biggest VLSI abortions of all time?  Bravo Fujitsu!
  1578.  * Fujitsu, the !#?!%$'d up processor people.  I bet if
  1579.  * you examined the microcode of the Swift you'd find
  1580.  * XXX's all over the place.
  1581.  */
  1582. poke_srmmu = poke_swift;
  1583. }
  1585. static void turbosparc_flush_cache_all(void)
  1586. {
  1587. flush_user_windows();
  1588. turbosparc_idflash_clear();
  1589. }
  1591. static void turbosparc_flush_cache_mm(struct mm_struct *mm)
  1592. {
  1593. FLUSH_BEGIN(mm)
  1594. flush_user_windows();
  1595. turbosparc_idflash_clear();
  1596. FLUSH_END
  1597. }
  1599. static void turbosparc_flush_cache_range(struct mm_struct *mm, unsigned long start, unsigned long end)
  1600. {
  1601. FLUSH_BEGIN(mm)
  1602. flush_user_windows();
  1603. turbosparc_idflash_clear();
  1604. FLUSH_END
  1605. }
  1607. static void turbosparc_flush_cache_page(struct vm_area_struct *vma, unsigned long page)
  1608. {
  1609. FLUSH_BEGIN(vma->vm_mm)
  1610. flush_user_windows();
  1611. if (vma->vm_flags & VM_EXEC)
  1612. turbosparc_flush_icache();
  1613. turbosparc_flush_dcache();
  1614. FLUSH_END
  1615. }
  1617. /* TurboSparc is copy-back, if we turn it on, but this does not work. */
  1618. static void turbosparc_flush_page_to_ram(unsigned long page)
  1619. {
  1620. #ifdef TURBOSPARC_WRITEBACK
  1621. volatile unsigned long clear;
  1623. if (srmmu_hwprobe(page))
  1624. turbosparc_flush_page_cache(page);
  1625. clear = srmmu_get_fstatus();
  1626. #endif
  1627. }
  1629. static void turbosparc_flush_sig_insns(struct mm_struct *mm, unsigned long insn_addr)
  1630. {
  1631. }
  1633. static void turbosparc_flush_page_for_dma(unsigned long page)
  1634. {
  1635. turbosparc_flush_dcache();
  1636. }
  1638. static void turbosparc_flush_tlb_all(void)
  1639. {
  1640. srmmu_flush_whole_tlb();
  1641. }
  1643. static void turbosparc_flush_tlb_mm(struct mm_struct *mm)
  1644. {
  1645. FLUSH_BEGIN(mm)
  1646. srmmu_flush_whole_tlb();
  1647. FLUSH_END
  1648. }
  1650. static void turbosparc_flush_tlb_range(struct mm_struct *mm, unsigned long start, unsigned long end)
  1651. {
  1652. FLUSH_BEGIN(mm)
  1653. srmmu_flush_whole_tlb();
  1654. FLUSH_END
  1655. }
  1657. static void turbosparc_flush_tlb_page(struct vm_area_struct *vma, unsigned long page)
  1658. {
  1659. FLUSH_BEGIN(vma->vm_mm)
  1660. srmmu_flush_whole_tlb();
  1661. FLUSH_END
  1662. }
  1665. static void __init poke_turbosparc(void)
  1666. {
  1667. unsigned long mreg = srmmu_get_mmureg();
  1668. unsigned long ccreg;
  1670. /* Clear any crap from the cache or else... */
  1671. turbosparc_flush_cache_all();
  1672. mreg &= ~(TURBOSPARC_ICENABLE | TURBOSPARC_DCENABLE); /* Temporarily disable I & D caches */
  1673. mreg &= ~(TURBOSPARC_PCENABLE); /* Don't check parity */
  1674. srmmu_set_mmureg(mreg);
  1676. ccreg = turbosparc_get_ccreg();
  1678. #ifdef TURBOSPARC_WRITEBACK
  1679. ccreg |= (TURBOSPARC_SNENABLE); /* Do DVMA snooping in Dcache */
  1680. ccreg &= ~(TURBOSPARC_uS2 | TURBOSPARC_WTENABLE);
  1681. /* Write-back D-cache, emulate VLSI
  1682.  * abortion number three, not number one */
  1683. #else
  1684. /* For now let's play safe, optimize later */
  1685. ccreg |= (TURBOSPARC_SNENABLE | TURBOSPARC_WTENABLE);
  1686. /* Do DVMA snooping in Dcache, Write-thru D-cache */
  1687. ccreg &= ~(TURBOSPARC_uS2);
  1688. /* Emulate VLSI abortion number three, not number one */
  1689. #endif
  1691. switch (ccreg & 7) {
  1692. case 0: /* No SE cache */
  1693. case 7: /* Test mode */
  1694. break;
  1695. default:
  1696. ccreg |= (TURBOSPARC_SCENABLE);
  1697. }
  1698. turbosparc_set_ccreg (ccreg);
  1700. mreg |= (TURBOSPARC_ICENABLE | TURBOSPARC_DCENABLE); /* I & D caches on */
  1701. mreg |= (TURBOSPARC_ICSNOOP); /* Icache snooping on */
  1702. srmmu_set_mmureg(mreg);
  1703. }
  1705. static void __init init_turbosparc(void)
  1706. {
  1707. srmmu_name = "Fujitsu TurboSparc";
  1708. srmmu_modtype = TurboSparc;
  1710. BTFIXUPSET_CALL(flush_cache_all, turbosparc_flush_cache_all, BTFIXUPCALL_NORM);
  1711. BTFIXUPSET_CALL(flush_cache_mm, turbosparc_flush_cache_mm, BTFIXUPCALL_NORM);
  1712. BTFIXUPSET_CALL(flush_cache_page, turbosparc_flush_cache_page, BTFIXUPCALL_NORM);
  1713. BTFIXUPSET_CALL(flush_cache_range, turbosparc_flush_cache_range, BTFIXUPCALL_NORM);
  1715. BTFIXUPSET_CALL(flush_tlb_all, turbosparc_flush_tlb_all, BTFIXUPCALL_NORM);
  1716. BTFIXUPSET_CALL(flush_tlb_mm, turbosparc_flush_tlb_mm, BTFIXUPCALL_NORM);
  1717. BTFIXUPSET_CALL(flush_tlb_page, turbosparc_flush_tlb_page, BTFIXUPCALL_NORM);
  1718. BTFIXUPSET_CALL(flush_tlb_range, turbosparc_flush_tlb_range, BTFIXUPCALL_NORM);
  1720. BTFIXUPSET_CALL(__flush_page_to_ram, turbosparc_flush_page_to_ram, BTFIXUPCALL_NORM);
  1722. BTFIXUPSET_CALL(flush_sig_insns, turbosparc_flush_sig_insns, BTFIXUPCALL_NOP);
  1723. BTFIXUPSET_CALL(flush_page_for_dma, turbosparc_flush_page_for_dma, BTFIXUPCALL_NORM);
  1725. poke_srmmu = poke_turbosparc;
  1726. }
  1728. static void __init poke_tsunami(void)
  1729. {
  1730. unsigned long mreg = srmmu_get_mmureg();
  1732. tsunami_flush_icache();
  1733. tsunami_flush_dcache();
  1734. mreg &= ~TSUNAMI_ITD;
  1735. mreg |= (TSUNAMI_IENAB | TSUNAMI_DENAB);
  1736. srmmu_set_mmureg(mreg);
  1737. }
  1739. static void __init init_tsunami(void)
  1740. {
  1741. /*
  1742.  * Tsunami's pretty sane, Sun and TI actually got it
  1743.  * somewhat right this time.  Fujitsu should have
  1744.  * taken some lessons from them.
  1745.  */
  1747. srmmu_name = "TI Tsunami";
  1748. srmmu_modtype = Tsunami;
  1750. BTFIXUPSET_CALL(flush_cache_all, tsunami_flush_cache_all, BTFIXUPCALL_NORM);
  1751. BTFIXUPSET_CALL(flush_cache_mm, tsunami_flush_cache_mm, BTFIXUPCALL_NORM);
  1752. BTFIXUPSET_CALL(flush_cache_page, tsunami_flush_cache_page, BTFIXUPCALL_NORM);
  1753. BTFIXUPSET_CALL(flush_cache_range, tsunami_flush_cache_range, BTFIXUPCALL_NORM);
  1756. BTFIXUPSET_CALL(flush_tlb_all, tsunami_flush_tlb_all, BTFIXUPCALL_NORM);
  1757. BTFIXUPSET_CALL(flush_tlb_mm, tsunami_flush_tlb_mm, BTFIXUPCALL_NORM);
  1758. BTFIXUPSET_CALL(flush_tlb_page, tsunami_flush_tlb_page, BTFIXUPCALL_NORM);
  1759. BTFIXUPSET_CALL(flush_tlb_range, tsunami_flush_tlb_range, BTFIXUPCALL_NORM);
  1761. BTFIXUPSET_CALL(__flush_page_to_ram, tsunami_flush_page_to_ram, BTFIXUPCALL_NOP);
  1762. BTFIXUPSET_CALL(flush_sig_insns, tsunami_flush_sig_insns, BTFIXUPCALL_NORM);
  1763. BTFIXUPSET_CALL(flush_page_for_dma, tsunami_flush_page_for_dma, BTFIXUPCALL_NORM);
  1765. poke_srmmu = poke_tsunami;
  1767. tsunami_setup_blockops();
  1768. }
  1770. static void __init poke_viking(void)
  1771. {
  1772. unsigned long mreg = srmmu_get_mmureg();
  1773. static int smp_catch;
  1775. if(viking_mxcc_present) {
  1776. unsigned long mxcc_control = mxcc_get_creg();
  1778. mxcc_control |= (MXCC_CTL_ECE | MXCC_CTL_PRE | MXCC_CTL_MCE);
  1779. mxcc_control &= ~(MXCC_CTL_RRC);
  1780. mxcc_set_creg(mxcc_control);
  1782. /*
  1783.  * We don't need memory parity checks.
  1784.  * XXX This is a mess, have to dig out later. ecd.
  1785. viking_mxcc_turn_off_parity(&mreg, &mxcc_control);
  1786.  */
  1788. /* We do cache ptables on MXCC. */
  1789. mreg |= VIKING_TCENABLE;
  1790. } else {
  1791. unsigned long bpreg;
  1793. mreg &= ~(VIKING_TCENABLE);
  1794. if(smp_catch++) {
  1795. /* Must disable mixed-cmd mode here for other cpu's. */
  1796. bpreg = viking_get_bpreg();
  1797. bpreg &= ~(VIKING_ACTION_MIX);
  1798. viking_set_bpreg(bpreg);
  1800. /* Just in case PROM does something funny. */
  1801. msi_set_sync();
  1802. }
  1803. }
  1805. mreg |= VIKING_SPENABLE;
  1806. mreg |= (VIKING_ICENABLE | VIKING_DCENABLE);
  1807. mreg |= VIKING_SBENABLE;
  1808. mreg &= ~(VIKING_ACENABLE);
  1809. srmmu_set_mmureg(mreg);
  1811. #ifdef CONFIG_SMP
  1812. /* Avoid unnecessary cross calls. */
  1813. BTFIXUPCOPY_CALL(flush_cache_all, local_flush_cache_all);
  1814. BTFIXUPCOPY_CALL(flush_cache_mm, local_flush_cache_mm);
  1815. BTFIXUPCOPY_CALL(flush_cache_range, local_flush_cache_range);
  1816. BTFIXUPCOPY_CALL(flush_cache_page, local_flush_cache_page);
  1817. BTFIXUPCOPY_CALL(__flush_page_to_ram, local_flush_page_to_ram);
  1818. BTFIXUPCOPY_CALL(flush_sig_insns, local_flush_sig_insns);
  1819. BTFIXUPCOPY_CALL(flush_page_for_dma, local_flush_page_for_dma);
  1820. btfixup();
  1821. #endif
  1822. }
  1824. static void __init init_viking(void)
  1825. {
  1826. unsigned long mreg = srmmu_get_mmureg();
  1828. /* Ahhh, the viking.  SRMMU VLSI abortion number two... */
  1829. if(mreg & VIKING_MMODE) {
  1830. srmmu_name = "TI Viking";
  1831. viking_mxcc_present = 0;
  1832. msi_set_sync();
  1834. BTFIXUPSET_CALL(pte_clear, srmmu_pte_clear, BTFIXUPCALL_NORM);
  1835. BTFIXUPSET_CALL(pmd_clear, srmmu_pmd_clear, BTFIXUPCALL_NORM);
  1836. BTFIXUPSET_CALL(pgd_clear, srmmu_pgd_clear, BTFIXUPCALL_NORM);
  1838. /*
  1839.  * We need this to make sure old viking takes no hits
  1840.  * on it's cache for dma snoops to workaround the
  1841.  * "load from non-cacheable memory" interrupt bug.
  1842.  * This is only necessary because of the new way in
  1843.  * which we use the IOMMU.
  1844.  */
  1845. BTFIXUPSET_CALL(flush_page_for_dma, viking_flush_page, BTFIXUPCALL_NORM);
  1847. flush_page_for_dma_global = 0;
  1848. } else {
  1849. srmmu_name = "TI Viking/MXCC";
  1850. viking_mxcc_present = 1;
  1852. srmmu_cache_pagetables = 1;
  1854. /* MXCC vikings lack the DMA snooping bug. */
  1855. BTFIXUPSET_CALL(flush_page_for_dma, viking_flush_page_for_dma, BTFIXUPCALL_NOP);
  1856. }
  1858. BTFIXUPSET_CALL(flush_cache_all, viking_flush_cache_all, BTFIXUPCALL_NORM);
  1859. BTFIXUPSET_CALL(flush_cache_mm, viking_flush_cache_mm, BTFIXUPCALL_NORM);
  1860. BTFIXUPSET_CALL(flush_cache_page, viking_flush_cache_page, BTFIXUPCALL_NORM);
  1861. BTFIXUPSET_CALL(flush_cache_range, viking_flush_cache_range, BTFIXUPCALL_NORM);
  1863. #ifdef CONFIG_SMP
  1864. if (sparc_cpu_model == sun4d) {
  1865. BTFIXUPSET_CALL(flush_tlb_all, sun4dsmp_flush_tlb_all, BTFIXUPCALL_NORM);
  1866. BTFIXUPSET_CALL(flush_tlb_mm, sun4dsmp_flush_tlb_mm, BTFIXUPCALL_NORM);
  1867. BTFIXUPSET_CALL(flush_tlb_page, sun4dsmp_flush_tlb_page, BTFIXUPCALL_NORM);
  1868. BTFIXUPSET_CALL(flush_tlb_range, sun4dsmp_flush_tlb_range, BTFIXUPCALL_NORM);
  1869. } else
  1870. #endif
  1871. {
  1872. BTFIXUPSET_CALL(flush_tlb_all, viking_flush_tlb_all, BTFIXUPCALL_NORM);
  1873. BTFIXUPSET_CALL(flush_tlb_mm, viking_flush_tlb_mm, BTFIXUPCALL_NORM);
  1874. BTFIXUPSET_CALL(flush_tlb_page, viking_flush_tlb_page, BTFIXUPCALL_NORM);
  1875. BTFIXUPSET_CALL(flush_tlb_range, viking_flush_tlb_range, BTFIXUPCALL_NORM);
  1876. }
  1878. BTFIXUPSET_CALL(__flush_page_to_ram, viking_flush_page_to_ram, BTFIXUPCALL_NOP);
  1879. BTFIXUPSET_CALL(flush_sig_insns, viking_flush_sig_insns, BTFIXUPCALL_NOP);
  1881. poke_srmmu = poke_viking;
  1882. }
  1884. /* Probe for the srmmu chip version. */
  1885. static void __init get_srmmu_type(void)
  1886. {
  1887. unsigned long mreg, psr;
  1888. unsigned long mod_typ, mod_rev, psr_typ, psr_vers;
  1890. srmmu_modtype = SRMMU_INVAL_MOD;
  1891. hwbug_bitmask = 0;
  1893. mreg = srmmu_get_mmureg(); psr = get_psr();
  1894. mod_typ = (mreg & 0xf0000000) >> 28;
  1895. mod_rev = (mreg & 0x0f000000) >> 24;
  1896. psr_typ = (psr >> 28) & 0xf;
  1897. psr_vers = (psr >> 24) & 0xf;
  1899. /* First, check for HyperSparc or Cypress. */
  1900. if(mod_typ == 1) {
  1901. switch(mod_rev) {
  1902. case 7:
  1903. /* UP or MP Hypersparc */
  1904. init_hypersparc();
  1905. break;
  1906. case 0:
  1907. case 2:
  1908. /* Uniprocessor Cypress */
  1909. init_cypress_604();
  1910. break;
  1911. case 10:
  1912. case 11:
  1913. case 12:
  1914. /* _REALLY OLD_ Cypress MP chips... */
  1915. case 13:
  1916. case 14:
  1917. case 15:
  1918. /* MP Cypress mmu/cache-controller */
  1919. init_cypress_605(mod_rev);
  1920. break;
  1921. default:
  1922. /* Some other Cypress revision, assume a 605. */
  1923. init_cypress_605(mod_rev);
  1924. break;
  1925. };
  1926. return;
  1927. }
  1929. /*
  1930.  * Now Fujitsu TurboSparc. It might happen that it is
  1931.  * in Swift emulation mode, so we will check later...
  1932.  */
  1933. if (psr_typ == 0 && psr_vers == 5) {
  1934. init_turbosparc();
  1935. return;
  1936. }
  1938. /* Next check for Fujitsu Swift. */
  1939. if(psr_typ == 0 && psr_vers == 4) {
  1940. int cpunode;
  1941. char node_str[128];
  1943. /* Look if it is not a TurboSparc emulating Swift... */
  1944. cpunode = prom_getchild(prom_root_node);
  1945. while((cpunode = prom_getsibling(cpunode)) != 0) {
  1946. prom_getstring(cpunode, "device_type", node_str, sizeof(node_str));
  1947. if(!strcmp(node_str, "cpu")) {
  1948. if (!prom_getintdefault(cpunode, "psr-implementation", 1) &&
  1949.     prom_getintdefault(cpunode, "psr-version", 1) == 5) {
  1950. init_turbosparc();
  1951. return;
  1952. }
  1953. break;
  1954. }
  1955. }
  1957. init_swift();
  1958. return;
  1959. }
  1961. /* Now the Viking family of srmmu. */
  1962. if(psr_typ == 4 &&
  1963.    ((psr_vers == 0) ||
  1964.     ((psr_vers == 1) && (mod_typ == 0) && (mod_rev == 0)))) {
  1965. init_viking();
  1966. return;
  1967. }
  1969. /* Finally the Tsunami. */
  1970. if(psr_typ == 4 && psr_vers == 1 && (mod_typ || mod_rev)) {
  1971. init_tsunami();
  1972. return;
  1973. }
  1975. /* Oh well */
  1976. srmmu_is_bad();
  1977. }
  1979. /* dont laugh, static pagetables */
  1980. static int srmmu_check_pgt_cache(int low, int high)
  1981. {
  1982. return 0;
  1983. }
  1985. extern unsigned long spwin_mmu_patchme, fwin_mmu_patchme,
  1986. tsetup_mmu_patchme, rtrap_mmu_patchme;
  1988. extern unsigned long spwin_srmmu_stackchk, srmmu_fwin_stackchk,
  1989. tsetup_srmmu_stackchk, srmmu_rett_stackchk;
  1991. extern unsigned long srmmu_fault;
  1993. #define PATCH_BRANCH(insn, dest) do { 
  1994. iaddr = &(insn); 
  1995. daddr = &(dest); 
  1996. *iaddr = SPARC_BRANCH((unsigned long) daddr, (unsigned long) iaddr); 
  1997. } while(0);
  1999. static void __init patch_window_trap_handlers(void)
  2000. {
  2001. unsigned long *iaddr, *daddr;
  2003. PATCH_BRANCH(spwin_mmu_patchme, spwin_srmmu_stackchk);
  2004. PATCH_BRANCH(fwin_mmu_patchme, srmmu_fwin_stackchk);
  2005. PATCH_BRANCH(tsetup_mmu_patchme, tsetup_srmmu_stackchk);
  2006. PATCH_BRANCH(rtrap_mmu_patchme, srmmu_rett_stackchk);
  2007. PATCH_BRANCH(sparc_ttable[SP_TRAP_TFLT].inst_three, srmmu_fault);
  2008. PATCH_BRANCH(sparc_ttable[SP_TRAP_DFLT].inst_three, srmmu_fault);
  2009. PATCH_BRANCH(sparc_ttable[SP_TRAP_DACC].inst_three, srmmu_fault);
  2010. }
  2012. #ifdef CONFIG_SMP
  2013. /* Local cross-calls. */
  2014. static void smp_flush_page_for_dma(unsigned long page)
  2015. {
  2016. xc1((smpfunc_t) BTFIXUP_CALL(local_flush_page_for_dma), page);
  2017. local_flush_page_for_dma(page);
  2018. }
  2020. #endif
  2022. /* Load up routines and constants for sun4m and sun4d mmu */
  2023. void __init ld_mmu_srmmu(void)
  2024. {
  2025. extern void ld_mmu_iommu(void);
  2026. extern void ld_mmu_iounit(void);
  2027. extern void ___xchg32_sun4md(void);
  2029. /* First the constants */
  2030. BTFIXUPSET_SIMM13(pmd_shift, SRMMU_PMD_SHIFT);
  2031. BTFIXUPSET_SETHI(pmd_size, SRMMU_PMD_SIZE);
  2032. BTFIXUPSET_SETHI(pmd_mask, SRMMU_PMD_MASK);
  2033. BTFIXUPSET_SIMM13(pgdir_shift, SRMMU_PGDIR_SHIFT);
  2034. BTFIXUPSET_SETHI(pgdir_size, SRMMU_PGDIR_SIZE);
  2035. BTFIXUPSET_SETHI(pgdir_mask, SRMMU_PGDIR_MASK);
  2037. BTFIXUPSET_SIMM13(ptrs_per_pte, SRMMU_PTRS_PER_PTE);
  2038. BTFIXUPSET_SIMM13(ptrs_per_pmd, SRMMU_PTRS_PER_PMD);
  2039. BTFIXUPSET_SIMM13(ptrs_per_pgd, SRMMU_PTRS_PER_PGD);
  2041. BTFIXUPSET_INT(page_none, pgprot_val(SRMMU_PAGE_NONE));
  2042. BTFIXUPSET_INT(page_shared, pgprot_val(SRMMU_PAGE_SHARED));
  2043. BTFIXUPSET_INT(page_copy, pgprot_val(SRMMU_PAGE_COPY));
  2044. BTFIXUPSET_INT(page_readonly, pgprot_val(SRMMU_PAGE_RDONLY));
  2045. BTFIXUPSET_INT(page_kernel, pgprot_val(SRMMU_PAGE_KERNEL));
  2046. page_kernel = pgprot_val(SRMMU_PAGE_KERNEL);
  2047. pg_iobits = SRMMU_VALID | SRMMU_WRITE | SRMMU_REF;
  2049. /* Functions */
  2050. #ifndef CONFIG_SMP
  2051. BTFIXUPSET_CALL(___xchg32, ___xchg32_sun4md, BTFIXUPCALL_SWAPG1G2);
  2052. #endif
  2053. BTFIXUPSET_CALL(do_check_pgt_cache, srmmu_check_pgt_cache, BTFIXUPCALL_NORM);
  2055. BTFIXUPSET_CALL(set_pte, srmmu_set_pte, BTFIXUPCALL_SWAPO0O1);
  2056. BTFIXUPSET_CALL(switch_mm, srmmu_switch_mm, BTFIXUPCALL_NORM);
  2058. BTFIXUPSET_CALL(pte_page, srmmu_pte_page, BTFIXUPCALL_NORM);
  2059. BTFIXUPSET_CALL(pmd_page, srmmu_pmd_page, BTFIXUPCALL_NORM);
  2060. BTFIXUPSET_CALL(pgd_page, srmmu_pgd_page, BTFIXUPCALL_NORM);
  2062. BTFIXUPSET_SETHI(none_mask, 0xF0000000); /* XXX P3: is it used? */
  2064. BTFIXUPSET_CALL(pte_present, srmmu_pte_present, BTFIXUPCALL_NORM);
  2065. BTFIXUPSET_CALL(pte_clear, srmmu_pte_clear, BTFIXUPCALL_SWAPO0G0);
  2067. BTFIXUPSET_CALL(pmd_bad, srmmu_pmd_bad, BTFIXUPCALL_NORM);
  2068. BTFIXUPSET_CALL(pmd_present, srmmu_pmd_present, BTFIXUPCALL_NORM);
  2069. BTFIXUPSET_CALL(pmd_clear, srmmu_pmd_clear, BTFIXUPCALL_SWAPO0G0);
  2071. BTFIXUPSET_CALL(pgd_none, srmmu_pgd_none, BTFIXUPCALL_NORM);
  2072. BTFIXUPSET_CALL(pgd_bad, srmmu_pgd_bad, BTFIXUPCALL_NORM);
  2073. BTFIXUPSET_CALL(pgd_present, srmmu_pgd_present, BTFIXUPCALL_NORM);
  2074. BTFIXUPSET_CALL(pgd_clear, srmmu_pgd_clear, BTFIXUPCALL_SWAPO0G0);
  2076. BTFIXUPSET_CALL(mk_pte, srmmu_mk_pte, BTFIXUPCALL_NORM);
  2077. BTFIXUPSET_CALL(mk_pte_phys, srmmu_mk_pte_phys, BTFIXUPCALL_NORM);
  2078. BTFIXUPSET_CALL(mk_pte_io, srmmu_mk_pte_io, BTFIXUPCALL_NORM);
  2079. BTFIXUPSET_CALL(pgd_set, srmmu_pgd_set, BTFIXUPCALL_NORM);
  2080. BTFIXUPSET_CALL(pmd_set, srmmu_pmd_set, BTFIXUPCALL_NORM);
  2082. BTFIXUPSET_INT(pte_modify_mask, SRMMU_CHG_MASK);
  2083. BTFIXUPSET_CALL(pmd_offset, srmmu_pmd_offset, BTFIXUPCALL_NORM);
  2084. BTFIXUPSET_CALL(pte_offset, srmmu_pte_offset, BTFIXUPCALL_NORM);
  2085. BTFIXUPSET_CALL(free_pte_fast, srmmu_free_pte_fast, BTFIXUPCALL_NORM);
  2086. BTFIXUPSET_CALL(pte_alloc_one_fast, srmmu_pte_alloc_one_fast, BTFIXUPCALL_NORM);
  2087. BTFIXUPSET_CALL(pte_alloc_one, srmmu_pte_alloc_one, BTFIXUPCALL_NORM);
  2088. BTFIXUPSET_CALL(free_pmd_fast, srmmu_free_pmd_fast, BTFIXUPCALL_NORM);
  2089. BTFIXUPSET_CALL(pmd_alloc_one_fast, srmmu_pmd_alloc_one_fast, BTFIXUPCALL_NORM);
  2090. BTFIXUPSET_CALL(free_pgd_fast, srmmu_free_pgd_fast, BTFIXUPCALL_NORM);
  2091. BTFIXUPSET_CALL(get_pgd_fast, srmmu_get_pgd_fast, BTFIXUPCALL_NORM);
  2093. BTFIXUPSET_HALF(pte_writei, SRMMU_WRITE);
  2094. BTFIXUPSET_HALF(pte_dirtyi, SRMMU_DIRTY);
  2095. BTFIXUPSET_HALF(pte_youngi, SRMMU_REF);
  2096. BTFIXUPSET_HALF(pte_wrprotecti, SRMMU_WRITE);
  2097. BTFIXUPSET_HALF(pte_mkcleani, SRMMU_DIRTY);
  2098. BTFIXUPSET_HALF(pte_mkoldi, SRMMU_REF);
  2099. BTFIXUPSET_CALL(pte_mkwrite, srmmu_pte_mkwrite, BTFIXUPCALL_ORINT(SRMMU_WRITE));
  2100. BTFIXUPSET_CALL(pte_mkdirty, srmmu_pte_mkdirty, BTFIXUPCALL_ORINT(SRMMU_DIRTY));
  2101. BTFIXUPSET_CALL(pte_mkyoung, srmmu_pte_mkyoung, BTFIXUPCALL_ORINT(SRMMU_REF));
  2102. BTFIXUPSET_CALL(update_mmu_cache, srmmu_update_mmu_cache, BTFIXUPCALL_NOP);
  2103. BTFIXUPSET_CALL(destroy_context, srmmu_destroy_context, BTFIXUPCALL_NORM);
  2105. BTFIXUPSET_CALL(mmu_info, srmmu_mmu_info, BTFIXUPCALL_NORM);
  2107. /* Task struct and kernel stack allocating/freeing. */
  2108. BTFIXUPSET_CALL(alloc_task_struct, srmmu_alloc_task_struct, BTFIXUPCALL_NORM);
  2109. BTFIXUPSET_CALL(free_task_struct, srmmu_free_task_struct, BTFIXUPCALL_NORM);
  2110. BTFIXUPSET_CALL(get_task_struct, srmmu_get_task_struct, BTFIXUPCALL_NORM);
  2112. get_srmmu_type();
  2113. patch_window_trap_handlers();
  2115. #ifdef CONFIG_SMP
  2116. /* El switcheroo... */
  2118. BTFIXUPCOPY_CALL(local_flush_cache_all, flush_cache_all);
  2119. BTFIXUPCOPY_CALL(local_flush_cache_mm, flush_cache_mm);
  2120. BTFIXUPCOPY_CALL(local_flush_cache_range, flush_cache_range);
  2121. BTFIXUPCOPY_CALL(local_flush_cache_page, flush_cache_page);
  2122. BTFIXUPCOPY_CALL(local_flush_tlb_all, flush_tlb_all);
  2123. BTFIXUPCOPY_CALL(local_flush_tlb_mm, flush_tlb_mm);
  2124. BTFIXUPCOPY_CALL(local_flush_tlb_range, flush_tlb_range);
  2125. BTFIXUPCOPY_CALL(local_flush_tlb_page, flush_tlb_page);
  2126. BTFIXUPCOPY_CALL(local_flush_page_to_ram, __flush_page_to_ram);
  2127. BTFIXUPCOPY_CALL(local_flush_sig_insns, flush_sig_insns);
  2128. BTFIXUPCOPY_CALL(local_flush_page_for_dma, flush_page_for_dma);
  2130. BTFIXUPSET_CALL(flush_cache_all, smp_flush_cache_all, BTFIXUPCALL_NORM);
  2131. BTFIXUPSET_CALL(flush_cache_mm, smp_flush_cache_mm, BTFIXUPCALL_NORM);
  2132. BTFIXUPSET_CALL(flush_cache_range, smp_flush_cache_range, BTFIXUPCALL_NORM);
  2133. BTFIXUPSET_CALL(flush_cache_page, smp_flush_cache_page, BTFIXUPCALL_NORM);
  2134. if (sparc_cpu_model != sun4d) {
  2135. BTFIXUPSET_CALL(flush_tlb_all, smp_flush_tlb_all, BTFIXUPCALL_NORM);
  2136. BTFIXUPSET_CALL(flush_tlb_mm, smp_flush_tlb_mm, BTFIXUPCALL_NORM);
  2137. BTFIXUPSET_CALL(flush_tlb_range, smp_flush_tlb_range, BTFIXUPCALL_NORM);
  2138. BTFIXUPSET_CALL(flush_tlb_page, smp_flush_tlb_page, BTFIXUPCALL_NORM);
  2139. }
  2140. BTFIXUPSET_CALL(__flush_page_to_ram, smp_flush_page_to_ram, BTFIXUPCALL_NORM);
  2141. BTFIXUPSET_CALL(flush_sig_insns, smp_flush_sig_insns, BTFIXUPCALL_NORM);
  2142. BTFIXUPSET_CALL(flush_page_for_dma, smp_flush_page_for_dma, BTFIXUPCALL_NORM);
  2143. #endif
  2145. if (sparc_cpu_model == sun4d)
  2146. ld_mmu_iounit();
  2147. else
  2148. ld_mmu_iommu();
  2149. #ifdef CONFIG_SMP
  2150. if (sparc_cpu_model == sun4d)
  2151. sun4d_init_smp();
  2152. else
  2153. sun4m_init_smp();
  2154. #endif
  2155. }