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

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

Linux/Unix编程

开发平台：

Unix_Linux

init.c：源码内容
  1. /*  $Id: init.c,v 1.207 2001/11/30 06:55:39 davem Exp $
  2.  *  arch/sparc64/mm/init.c
  3.  *
  4.  *  Copyright (C) 1996-1999 David S. Miller (davem@caip.rutgers.edu)
  5.  *  Copyright (C) 1997-1999 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
  6.  */
  7.  
  8. #include <linux/config.h>
  9. #include <linux/kernel.h>
  10. #include <linux/sched.h>
  11. #include <linux/string.h>
  12. #include <linux/init.h>
  13. #include <linux/bootmem.h>
  14. #include <linux/mm.h>
  15. #include <linux/slab.h>
  16. #include <linux/blk.h>
  17. #include <linux/swap.h>
  18. #include <linux/swapctl.h>
  19. #include <linux/pagemap.h>
  20. #include <linux/fs.h>
  21. #include <linux/seq_file.h>
  23. #include <asm/head.h>
  24. #include <asm/system.h>
  25. #include <asm/page.h>
  26. #include <asm/pgalloc.h>
  27. #include <asm/pgtable.h>
  28. #include <asm/oplib.h>
  29. #include <asm/iommu.h>
  30. #include <asm/io.h>
  31. #include <asm/uaccess.h>
  32. #include <asm/mmu_context.h>
  33. #include <asm/dma.h>
  34. #include <asm/starfire.h>
  35. #include <asm/tlb.h>
  36. #include <asm/spitfire.h>
  38. mmu_gather_t mmu_gathers[NR_CPUS];
  40. extern void device_scan(void);
  42. struct sparc_phys_banks sp_banks[SPARC_PHYS_BANKS];
  44. unsigned long *sparc64_valid_addr_bitmap;
  46. /* Ugly, but necessary... -DaveM */
  47. unsigned long phys_base;
  49. enum ultra_tlb_layout tlb_type = spitfire;
  51. /* get_new_mmu_context() uses "cache + 1".  */
  52. spinlock_t ctx_alloc_lock = SPIN_LOCK_UNLOCKED;
  53. unsigned long tlb_context_cache = CTX_FIRST_VERSION - 1;
  54. #define CTX_BMAP_SLOTS (1UL << (CTX_VERSION_SHIFT - 6))
  55. unsigned long mmu_context_bmap[CTX_BMAP_SLOTS];
  57. /* References to section boundaries */
  58. extern char __init_begin, __init_end, _start, _end, etext, edata;
  60. /* Initial ramdisk setup */
  61. extern unsigned int sparc_ramdisk_image;
  62. extern unsigned int sparc_ramdisk_size;
  64. struct page *mem_map_zero;
  66. int bigkernel = 0;
  68. int do_check_pgt_cache(int low, int high)
  69. {
  70.         int freed = 0;
  72. if (pgtable_cache_size > high) {
  73. do {
  74. #ifdef CONFIG_SMP
  75. if (pgd_quicklist)
  76. free_pgd_slow(get_pgd_fast()), freed++;
  77. #endif
  78. if (pte_quicklist[0])
  79. free_pte_slow(pte_alloc_one_fast(NULL, 0)), freed++;
  80. if (pte_quicklist[1])
  81. free_pte_slow(pte_alloc_one_fast(NULL, 1 << (PAGE_SHIFT + 10))), freed++;
  82. } while (pgtable_cache_size > low);
  83. }
  84. #ifndef CONFIG_SMP 
  85.         if (pgd_cache_size > high / 4) {
  86. struct page *page, *page2;
  87.                 for (page2 = NULL, page = (struct page *)pgd_quicklist; page;) {
  88.                         if ((unsigned long)page->pprev_hash == 3) {
  89.                                 if (page2)
  90.                                         page2->next_hash = page->next_hash;
  91.                                 else
  92.                                         (struct page *)pgd_quicklist = page->next_hash;
  93.                                 page->next_hash = NULL;
  94.                                 page->pprev_hash = NULL;
  95.                                 pgd_cache_size -= 2;
  96.                                 __free_page(page);
  97.                                 freed++;
  98.                                 if (page2)
  99.                                         page = page2->next_hash;
  100.                                 else
  101.                                         page = (struct page *)pgd_quicklist;
  102.                                 if (pgd_cache_size <= low / 4)
  103.                                         break;
  104.                                 continue;
  105.                         }
  106.                         page2 = page;
  107.                         page = page->next_hash;
  108.                 }
  109.         }
  110. #endif
  111.         return freed;
  112. }
  114. extern void __update_mmu_cache(struct vm_area_struct *, unsigned long, pte_t);
  116. #ifdef CONFIG_DEBUG_DCFLUSH
  117. atomic_t dcpage_flushes = ATOMIC_INIT(0);
  118. #ifdef CONFIG_SMP
  119. atomic_t dcpage_flushes_xcall = ATOMIC_INIT(0);
  120. #endif
  121. #endif
  123. __inline__ void flush_dcache_page_impl(struct page *page)
  124. {
  125. #ifdef CONFIG_DEBUG_DCFLUSH
  126. atomic_inc(&dcpage_flushes);
  127. #endif
  129. #if (L1DCACHE_SIZE > PAGE_SIZE)
  130. __flush_dcache_page(page->virtual,
  131.     ((tlb_type == spitfire) &&
  132.      page->mapping != NULL));
  133. #else
  134. if (page->mapping != NULL &&
  135.     tlb_type == spitfire)
  136. __flush_icache_page(__pa(page->virtual));
  137. #endif
  138. }
  140. #define PG_dcache_dirty PG_arch_1
  142. #define dcache_dirty_cpu(page) 
  143. (((page)->flags >> 24) & (NR_CPUS - 1UL))
  145. static __inline__ void set_dcache_dirty(struct page *page)
  146. {
  147. unsigned long mask = smp_processor_id();
  148. unsigned long non_cpu_bits = (1UL << 24UL) - 1UL;
  149. mask = (mask << 24) | (1UL << PG_dcache_dirty);
  150. __asm__ __volatile__("1:nt"
  151.      "ldx [%2], %%g7nt"
  152.      "and %%g7, %1, %%g5nt"
  153.      "or %%g5, %0, %%g5nt"
  154.      "casx [%2], %%g7, %%g5nt"
  155.      "cmp %%g7, %%g5nt"
  156.      "bne,pn %%xcc, 1bnt"
  157.      " membar #StoreLoad | #StoreStore"
  158.      : /* no outputs */
  159.      : "r" (mask), "r" (non_cpu_bits), "r" (&page->flags)
  160.      : "g5", "g7");
  161. }
  163. static __inline__ void clear_dcache_dirty_cpu(struct page *page, unsigned long cpu)
  164. {
  165. unsigned long mask = (1UL << PG_dcache_dirty);
  167. __asm__ __volatile__("! test_and_clear_dcache_dirtyn"
  168.      "1:nt"
  169.      "ldx [%2], %%g7nt"
  170.      "srlx %%g7, 24, %%g5nt"
  171.      "cmp %%g5, %0nt"
  172.      "bne,pn %%icc, 2fnt"
  173.      " andn %%g7, %1, %%g5nt"
  174.      "casx [%2], %%g7, %%g5nt"
  175.      "cmp %%g7, %%g5nt"
  176.      "bne,pn %%xcc, 1bnt"
  177.      " membar #StoreLoad | #StoreStoren"
  178.      "2:"
  179.      : /* no outputs */
  180.      : "r" (cpu), "r" (mask), "r" (&page->flags)
  181.      : "g5", "g7");
  182. }
  184. void update_mmu_cache(struct vm_area_struct *vma, unsigned long address, pte_t pte)
  185. {
  186. struct page *page = pte_page(pte);
  187. unsigned long pg_flags;
  189. if (VALID_PAGE(page) &&
  190.     page->mapping &&
  191.     ((pg_flags = page->flags) & (1UL << PG_dcache_dirty))) {
  192. int cpu = (pg_flags >> 24);
  194. /* This is just to optimize away some function calls
  195.  * in the SMP case.
  196.  */
  197. if (cpu == smp_processor_id())
  198. flush_dcache_page_impl(page);
  199. else
  200. smp_flush_dcache_page_impl(page, cpu);
  202. clear_dcache_dirty_cpu(page, cpu);
  203. }
  204. __update_mmu_cache(vma, address, pte);
  205. }
  207. void flush_dcache_page(struct page *page)
  208. {
  209. int dirty = test_bit(PG_dcache_dirty, &page->flags);
  210. int dirty_cpu = dcache_dirty_cpu(page);
  212. if (page->mapping &&
  213.     page->mapping->i_mmap == NULL &&
  214.     page->mapping->i_mmap_shared == NULL) {
  215. if (dirty) {
  216. if (dirty_cpu == smp_processor_id())
  217. return;
  218. smp_flush_dcache_page_impl(page, dirty_cpu);
  219. }
  220. set_dcache_dirty(page);
  221. } else {
  222. /* We could delay the flush for the !page->mapping
  223.  * case too.  But that case is for exec env/arg
  224.  * pages and those are %99 certainly going to get
  225.  * faulted into the tlb (and thus flushed) anyways.
  226.  */
  227. flush_dcache_page_impl(page);
  228. }
  229. }
  231. void flush_icache_range(unsigned long start, unsigned long end)
  232. {
  233. /* Cheetah has coherent I-cache. */
  234. if (tlb_type == spitfire) {
  235. unsigned long kaddr;
  237. for (kaddr = start; kaddr < end; kaddr += PAGE_SIZE)
  238. __flush_icache_page(__get_phys(kaddr));
  239. }
  240. }
  242. void show_mem(void)
  243. {
  244. printk("Mem-info:n");
  245. show_free_areas();
  246. printk("Free swap:       %6dkBn",
  247.        nr_swap_pages << (PAGE_SHIFT-10));
  248. printk("%ld pages of RAMn", num_physpages);
  249. printk("%d free pagesn", nr_free_pages());
  250. printk("%d pages in page table cachen",pgtable_cache_size);
  251. #ifndef CONFIG_SMP
  252. printk("%d entries in page dir cachen",pgd_cache_size);
  253. #endif
  254. show_buffers();
  255. }
  257. void mmu_info(struct seq_file *m)
  258. {
  259. if (tlb_type == cheetah)
  260. seq_printf(m, "MMU Typet: Cheetahn");
  261. else if (tlb_type == cheetah_plus)
  262. seq_printf(m, "MMU Typet: Cheetah+n");
  263. else if (tlb_type == spitfire)
  264. seq_printf(m, "MMU Typet: Spitfiren");
  265. else
  266. seq_printf(m, "MMU Typet: ???n");
  268. #ifdef CONFIG_DEBUG_DCFLUSH
  269. seq_printf(m, "DCPageFlushest: %dn",
  270.    atomic_read(&dcpage_flushes));
  271. #ifdef CONFIG_SMP
  272. seq_printf(m, "DCPageFlushesXCt: %dn",
  273.    atomic_read(&dcpage_flushes_xcall));
  274. #endif /* CONFIG_SMP */
  275. #endif /* CONFIG_DEBUG_DCFLUSH */
  276. }
  278. struct linux_prom_translation {
  279. unsigned long virt;
  280. unsigned long size;
  281. unsigned long data;
  282. };
  284. extern unsigned long prom_boot_page;
  285. extern void prom_remap(unsigned long physpage, unsigned long virtpage, int mmu_ihandle);
  286. extern int prom_get_mmu_ihandle(void);
  287. extern void register_prom_callbacks(void);
  289. /* Exported for SMP bootup purposes. */
  290. unsigned long kern_locked_tte_data;
  292. void __init early_pgtable_allocfail(char *type)
  293. {
  294. prom_printf("inherit_prom_mappings: Cannot alloc kernel %s.n", type);
  295. prom_halt();
  296. }
  298. #define BASE_PAGE_SIZE 8192
  299. static pmd_t *prompmd;
  301. /*
  302.  * Translate PROM's mapping we capture at boot time into physical address.
  303.  * The second parameter is only set from prom_callback() invocations.
  304.  */
  305. unsigned long prom_virt_to_phys(unsigned long promva, int *error)
  306. {
  307. pmd_t *pmdp = prompmd + ((promva >> 23) & 0x7ff);
  308. pte_t *ptep;
  309. unsigned long base;
  311. if (pmd_none(*pmdp)) {
  312. if (error)
  313. *error = 1;
  314. return(0);
  315. }
  316. ptep = (pte_t *)pmd_page(*pmdp) + ((promva >> 13) & 0x3ff);
  317. if (!pte_present(*ptep)) {
  318. if (error)
  319. *error = 1;
  320. return(0);
  321. }
  322. if (error) {
  323. *error = 0;
  324. return(pte_val(*ptep));
  325. }
  326. base = pte_val(*ptep) & _PAGE_PADDR;
  327. return(base + (promva & (BASE_PAGE_SIZE - 1)));
  328. }
  330. static void inherit_prom_mappings(void)
  331. {
  332. struct linux_prom_translation *trans;
  333. unsigned long phys_page, tte_vaddr, tte_data;
  334. void (*remap_func)(unsigned long, unsigned long, int);
  335. pmd_t *pmdp;
  336. pte_t *ptep;
  337. int node, n, i, tsz;
  338. extern unsigned int obp_iaddr_patch[2], obp_daddr_patch[2];
  340. node = prom_finddevice("/virtual-memory");
  341. n = prom_getproplen(node, "translations");
  342. if (n == 0 || n == -1) {
  343. prom_printf("Couldn't get translation propertyn");
  344. prom_halt();
  345. }
  346. n += 5 * sizeof(struct linux_prom_translation);
  347. for (tsz = 1; tsz < n; tsz <<= 1)
  348. /* empty */;
  349. trans = __alloc_bootmem(tsz, SMP_CACHE_BYTES, 0UL);
  350. if (trans == NULL) {
  351. prom_printf("inherit_prom_mappings: Cannot alloc translations.n");
  352. prom_halt();
  353. }
  354. memset(trans, 0, tsz);
  356. if ((n = prom_getproperty(node, "translations", (char *)trans, tsz)) == -1) {
  357. prom_printf("Couldn't get translation propertyn");
  358. prom_halt();
  359. }
  360. n = n / sizeof(*trans);
  362. /*
  363.  * The obp translations are saved based on 8k pagesize, since obp can use
  364.  * a mixture of pagesizes. Misses to the 0xf0000000 - 0x100000000, ie obp 
  365.  * range, are handled in entry.S and do not use the vpte scheme (see rant
  366.  * in inherit_locked_prom_mappings()).
  367.  */
  368. #define OBP_PMD_SIZE 2048
  369. prompmd = __alloc_bootmem(OBP_PMD_SIZE, OBP_PMD_SIZE, 0UL);
  370. if (prompmd == NULL)
  371. early_pgtable_allocfail("pmd");
  372. memset(prompmd, 0, OBP_PMD_SIZE);
  373. for (i = 0; i < n; i++) {
  374. unsigned long vaddr;
  376. if (trans[i].virt >= LOW_OBP_ADDRESS && trans[i].virt < HI_OBP_ADDRESS) {
  377. for (vaddr = trans[i].virt;
  378.      ((vaddr < trans[i].virt + trans[i].size) && 
  379.      (vaddr < HI_OBP_ADDRESS));
  380.      vaddr += BASE_PAGE_SIZE) {
  381. unsigned long val;
  383. pmdp = prompmd + ((vaddr >> 23) & 0x7ff);
  384. if (pmd_none(*pmdp)) {
  385. ptep = __alloc_bootmem(BASE_PAGE_SIZE,
  386.        BASE_PAGE_SIZE,
  387.        0UL);
  388. if (ptep == NULL)
  389. early_pgtable_allocfail("pte");
  390. memset(ptep, 0, BASE_PAGE_SIZE);
  391. pmd_set(pmdp, ptep);
  392. }
  393. ptep = (pte_t *)pmd_page(*pmdp) +
  394. ((vaddr >> 13) & 0x3ff);
  396. val = trans[i].data;
  398. /* Clear diag TTE bits. */
  399. if (tlb_type == spitfire)
  400. val &= ~0x0003fe0000000000UL;
  402. set_pte (ptep, __pte(val | _PAGE_MODIFIED));
  403. trans[i].data += BASE_PAGE_SIZE;
  404. }
  405. }
  406. }
  407. phys_page = __pa(prompmd);
  408. obp_iaddr_patch[0] |= (phys_page >> 10);
  409. obp_iaddr_patch[1] |= (phys_page & 0x3ff);
  410. flushi((long)&obp_iaddr_patch[0]);
  411. obp_daddr_patch[0] |= (phys_page >> 10);
  412. obp_daddr_patch[1] |= (phys_page & 0x3ff);
  413. flushi((long)&obp_daddr_patch[0]);
  415. /* Now fixup OBP's idea about where we really are mapped. */
  416. prom_printf("Remapping the kernel... ");
  418. /* Spitfire Errata #32 workaround */
  419. __asm__ __volatile__("stxa %0, [%1] %2nt"
  420.      "flush %%g6"
  421.      : /* No outputs */
  422.      : "r" (0),
  423.      "r" (PRIMARY_CONTEXT), "i" (ASI_DMMU));
  425. switch (tlb_type) {
  426. default:
  427. case spitfire:
  428. phys_page = spitfire_get_dtlb_data(sparc64_highest_locked_tlbent());
  429. break;
  431. case cheetah:
  432. case cheetah_plus:
  433. phys_page = cheetah_get_litlb_data(sparc64_highest_locked_tlbent());
  434. break;
  435. };
  437. phys_page &= _PAGE_PADDR;
  438. phys_page += ((unsigned long)&prom_boot_page -
  439.       (unsigned long)KERNBASE);
  441. if (tlb_type == spitfire) {
  442. /* Lock this into i/d tlb entry 59 */
  443. __asm__ __volatile__(
  444. "stxa %%g0, [%2] %3nt"
  445. "stxa %0, [%1] %4nt"
  446. "membar #Syncnt"
  447. "flush %%g6nt"
  448. "stxa %%g0, [%2] %5nt"
  449. "stxa %0, [%1] %6nt"
  450. "membar #Syncnt"
  451. "flush %%g6"
  452. : : "r" (phys_page | _PAGE_VALID | _PAGE_SZ8K | _PAGE_CP |
  453.  _PAGE_CV | _PAGE_P | _PAGE_L | _PAGE_W),
  454. "r" (59 << 3), "r" (TLB_TAG_ACCESS),
  455. "i" (ASI_DMMU), "i" (ASI_DTLB_DATA_ACCESS),
  456. "i" (ASI_IMMU), "i" (ASI_ITLB_DATA_ACCESS)
  457. : "memory");
  458. } else if (tlb_type == cheetah || tlb_type == cheetah_plus) {
  459. /* Lock this into i/d tlb-0 entry 11 */
  460. __asm__ __volatile__(
  461. "stxa %%g0, [%2] %3nt"
  462. "stxa %0, [%1] %4nt"
  463. "membar #Syncnt"
  464. "flush %%g6nt"
  465. "stxa %%g0, [%2] %5nt"
  466. "stxa %0, [%1] %6nt"
  467. "membar #Syncnt"
  468. "flush %%g6"
  469. : : "r" (phys_page | _PAGE_VALID | _PAGE_SZ8K | _PAGE_CP |
  470.  _PAGE_CV | _PAGE_P | _PAGE_L | _PAGE_W),
  471. "r" ((0 << 16) | (11 << 3)), "r" (TLB_TAG_ACCESS),
  472. "i" (ASI_DMMU), "i" (ASI_DTLB_DATA_ACCESS),
  473. "i" (ASI_IMMU), "i" (ASI_ITLB_DATA_ACCESS)
  474. : "memory");
  475. } else {
  476. /* Implement me :-) */
  477. BUG();
  478. }
  480. tte_vaddr = (unsigned long) KERNBASE;
  482. /* Spitfire Errata #32 workaround */
  483. __asm__ __volatile__("stxa %0, [%1] %2nt"
  484.      "flush %%g6"
  485.      : /* No outputs */
  486.      : "r" (0),
  487.      "r" (PRIMARY_CONTEXT), "i" (ASI_DMMU));
  489. if (tlb_type == spitfire)
  490. tte_data = spitfire_get_dtlb_data(sparc64_highest_locked_tlbent());
  491. else
  492. tte_data = cheetah_get_ldtlb_data(sparc64_highest_locked_tlbent());
  494. kern_locked_tte_data = tte_data;
  496. remap_func = (void *)  ((unsigned long) &prom_remap -
  497. (unsigned long) &prom_boot_page);
  500. /* Spitfire Errata #32 workaround */
  501. __asm__ __volatile__("stxa %0, [%1] %2nt"
  502.      "flush %%g6"
  503.      : /* No outputs */
  504.      : "r" (0),
  505.      "r" (PRIMARY_CONTEXT), "i" (ASI_DMMU));
  507. remap_func((tlb_type == spitfire ?
  508.     (spitfire_get_dtlb_data(sparc64_highest_locked_tlbent()) & _PAGE_PADDR) :
  509.     (cheetah_get_litlb_data(sparc64_highest_locked_tlbent()) & _PAGE_PADDR)),
  510.    (unsigned long) KERNBASE,
  511.    prom_get_mmu_ihandle());
  513. if (bigkernel)
  514. remap_func(((tte_data + 0x400000) & _PAGE_PADDR),
  515. (unsigned long) KERNBASE + 0x400000, prom_get_mmu_ihandle());
  517. /* Flush out that temporary mapping. */
  518. spitfire_flush_dtlb_nucleus_page(0x0);
  519. spitfire_flush_itlb_nucleus_page(0x0);
  521. /* Now lock us back into the TLBs via OBP. */
  522. prom_dtlb_load(sparc64_highest_locked_tlbent(), tte_data, tte_vaddr);
  523. prom_itlb_load(sparc64_highest_locked_tlbent(), tte_data, tte_vaddr);
  524. if (bigkernel) {
  525. prom_dtlb_load(sparc64_highest_locked_tlbent()-1, tte_data + 0x400000, 
  526. tte_vaddr + 0x400000);
  527. prom_itlb_load(sparc64_highest_locked_tlbent()-1, tte_data + 0x400000, 
  528. tte_vaddr + 0x400000);
  529. }
  531. /* Re-read translations property. */
  532. if ((n = prom_getproperty(node, "translations", (char *)trans, tsz)) == -1) {
  533. prom_printf("Couldn't get translation propertyn");
  534. prom_halt();
  535. }
  536. n = n / sizeof(*trans);
  538. for (i = 0; i < n; i++) {
  539. unsigned long vaddr = trans[i].virt;
  540. unsigned long size = trans[i].size;
  542. if (vaddr < 0xf0000000UL) {
  543. unsigned long avoid_start = (unsigned long) KERNBASE;
  544. unsigned long avoid_end = avoid_start + (4 * 1024 * 1024);
  546. if (bigkernel)
  547. avoid_end += (4 * 1024 * 1024);
  548. if (vaddr < avoid_start) {
  549. unsigned long top = vaddr + size;
  551. if (top > avoid_start)
  552. top = avoid_start;
  553. prom_unmap(top - vaddr, vaddr);
  554. }
  555. if ((vaddr + size) > avoid_end) {
  556. unsigned long bottom = vaddr;
  558. if (bottom < avoid_end)
  559. bottom = avoid_end;
  560. prom_unmap((vaddr + size) - bottom, bottom);
  561. }
  562. }
  563. }
  565. prom_printf("done.n");
  567. register_prom_callbacks();
  568. }
  570. /* The OBP specifications for sun4u mark 0xfffffffc00000000 and
  571.  * upwards as reserved for use by the firmware (I wonder if this
  572.  * will be the same on Cheetah...).  We use this virtual address
  573.  * range for the VPTE table mappings of the nucleus so we need
  574.  * to zap them when we enter the PROM.  -DaveM
  575.  */
  576. static void __flush_nucleus_vptes(void)
  577. {
  578. unsigned long prom_reserved_base = 0xfffffffc00000000UL;
  579. int i;
  581. /* Only DTLB must be checked for VPTE entries. */
  582. if (tlb_type == spitfire) {
  583. for (i = 0; i < 63; i++) {
  584. unsigned long tag;
  586. /* Spitfire Errata #32 workaround */
  587. __asm__ __volatile__("stxa %0, [%1] %2nt"
  588.      "flush %%g6"
  589.      : /* No outputs */
  590.      : "r" (0),
  591.      "r" (PRIMARY_CONTEXT), "i" (ASI_DMMU));
  593. tag = spitfire_get_dtlb_tag(i);
  594. if (((tag & ~(PAGE_MASK)) == 0) &&
  595.     ((tag &  (PAGE_MASK)) >= prom_reserved_base)) {
  596. __asm__ __volatile__("stxa %%g0, [%0] %1nt"
  597.      "membar #Sync"
  598.      : /* no outputs */
  599.      : "r" (TLB_TAG_ACCESS), "i" (ASI_DMMU));
  600. spitfire_put_dtlb_data(i, 0x0UL);
  601. }
  602. }
  603. } else if (tlb_type == cheetah || tlb_type == cheetah_plus) {
  604. for (i = 0; i < 512; i++) {
  605. unsigned long tag = cheetah_get_dtlb_tag(i, 2);
  607. if ((tag & ~PAGE_MASK) == 0 &&
  608.     (tag & PAGE_MASK) >= prom_reserved_base) {
  609. __asm__ __volatile__("stxa %%g0, [%0] %1nt"
  610.      "membar #Sync"
  611.      : /* no outputs */
  612.      : "r" (TLB_TAG_ACCESS), "i" (ASI_DMMU));
  613. cheetah_put_dtlb_data(i, 0x0UL, 2);
  614. }
  616. if (tlb_type != cheetah_plus)
  617. continue;
  619. tag = cheetah_get_dtlb_tag(i, 3);
  621. if ((tag & ~PAGE_MASK) == 0 &&
  622.     (tag & PAGE_MASK) >= prom_reserved_base) {
  623. __asm__ __volatile__("stxa %%g0, [%0] %1nt"
  624.      "membar #Sync"
  625.      : /* no outputs */
  626.      : "r" (TLB_TAG_ACCESS), "i" (ASI_DMMU));
  627. cheetah_put_dtlb_data(i, 0x0UL, 3);
  628. }
  629. }
  630. } else {
  631. /* Implement me :-) */
  632. BUG();
  633. }
  634. }
  636. static int prom_ditlb_set;
  637. struct prom_tlb_entry {
  638. int tlb_ent;
  639. unsigned long tlb_tag;
  640. unsigned long tlb_data;
  641. };
  642. struct prom_tlb_entry prom_itlb[16], prom_dtlb[16];
  644. void prom_world(int enter)
  645. {
  646. unsigned long pstate;
  647. int i;
  649. if (!enter)
  650. set_fs(current->thread.current_ds);
  652. if (!prom_ditlb_set)
  653. return;
  655. /* Make sure the following runs atomically. */
  656. __asm__ __volatile__("flushwnt"
  657.      "rdpr %%pstate, %0nt"
  658.      "wrpr %0, %1, %%pstate"
  659.      : "=r" (pstate)
  660.      : "i" (PSTATE_IE));
  662. if (enter) {
  663. /* Kick out nucleus VPTEs. */
  664. __flush_nucleus_vptes();
  666. /* Install PROM world. */
  667. for (i = 0; i < 16; i++) {
  668. if (prom_dtlb[i].tlb_ent != -1) {
  669. __asm__ __volatile__("stxa %0, [%1] %2nt"
  670.      "membar #Sync"
  671. : : "r" (prom_dtlb[i].tlb_tag), "r" (TLB_TAG_ACCESS),
  672. "i" (ASI_DMMU));
  673. if (tlb_type == spitfire)
  674. spitfire_put_dtlb_data(prom_dtlb[i].tlb_ent,
  675.        prom_dtlb[i].tlb_data);
  676. else if (tlb_type == cheetah || tlb_type == cheetah_plus)
  677. cheetah_put_ldtlb_data(prom_dtlb[i].tlb_ent,
  678.        prom_dtlb[i].tlb_data);
  679. }
  680. if (prom_itlb[i].tlb_ent != -1) {
  681. __asm__ __volatile__("stxa %0, [%1] %2nt"
  682.      "membar #Sync"
  683.      : : "r" (prom_itlb[i].tlb_tag),
  684.      "r" (TLB_TAG_ACCESS),
  685.      "i" (ASI_IMMU));
  686. if (tlb_type == spitfire)
  687. spitfire_put_itlb_data(prom_itlb[i].tlb_ent,
  688.        prom_itlb[i].tlb_data);
  689. else if (tlb_type == cheetah || tlb_type == cheetah_plus)
  690. cheetah_put_litlb_data(prom_itlb[i].tlb_ent,
  691.        prom_itlb[i].tlb_data);
  692. }
  693. }
  694. } else {
  695. for (i = 0; i < 16; i++) {
  696. if (prom_dtlb[i].tlb_ent != -1) {
  697. __asm__ __volatile__("stxa %%g0, [%0] %1nt"
  698.      "membar #Sync"
  699. : : "r" (TLB_TAG_ACCESS), "i" (ASI_DMMU));
  700. if (tlb_type == spitfire)
  701. spitfire_put_dtlb_data(prom_dtlb[i].tlb_ent, 0x0UL);
  702. else
  703. cheetah_put_ldtlb_data(prom_dtlb[i].tlb_ent, 0x0UL);
  704. }
  705. if (prom_itlb[i].tlb_ent != -1) {
  706. __asm__ __volatile__("stxa %%g0, [%0] %1nt"
  707.      "membar #Sync"
  708.      : : "r" (TLB_TAG_ACCESS),
  709.      "i" (ASI_IMMU));
  710. if (tlb_type == spitfire)
  711. spitfire_put_itlb_data(prom_itlb[i].tlb_ent, 0x0UL);
  712. else
  713. cheetah_put_litlb_data(prom_itlb[i].tlb_ent, 0x0UL);
  714. }
  715. }
  716. }
  717. __asm__ __volatile__("wrpr %0, 0, %%pstate"
  718.      : : "r" (pstate));
  719. }
  721. void inherit_locked_prom_mappings(int save_p)
  722. {
  723. int i;
  724. int dtlb_seen = 0;
  725. int itlb_seen = 0;
  727. /* Fucking losing PROM has more mappings in the TLB, but
  728.  * it (conveniently) fails to mention any of these in the
  729.  * translations property.  The only ones that matter are
  730.  * the locked PROM tlb entries, so we impose the following
  731.  * irrecovable rule on the PROM, it is allowed 8 locked
  732.  * entries in the ITLB and 8 in the DTLB.
  733.  *
  734.  * Supposedly the upper 16GB of the address space is
  735.  * reserved for OBP, BUT I WISH THIS WAS DOCUMENTED
  736.  * SOMEWHERE!!!!!!!!!!!!!!!!!  Furthermore the entire interface
  737.  * used between the client program and the firmware on sun5
  738.  * systems to coordinate mmu mappings is also COMPLETELY
  739.  * UNDOCUMENTED!!!!!! Thanks S(t)un!
  740.  */
  741. if (save_p) {
  742. for (i = 0; i < 16; i++) {
  743. prom_itlb[i].tlb_ent = -1;
  744. prom_dtlb[i].tlb_ent = -1;
  745. }
  746. }
  747. if (tlb_type == spitfire) {
  748. int high = SPITFIRE_HIGHEST_LOCKED_TLBENT - bigkernel;
  749. for (i = 0; i < high; i++) {
  750. unsigned long data;
  752. /* Spitfire Errata #32 workaround */
  753. __asm__ __volatile__("stxa %0, [%1] %2nt"
  754.      "flush %%g6"
  755.      : /* No outputs */
  756.      : "r" (0),
  757.      "r" (PRIMARY_CONTEXT), "i" (ASI_DMMU));
  759. data = spitfire_get_dtlb_data(i);
  760. if ((data & (_PAGE_L|_PAGE_VALID)) == (_PAGE_L|_PAGE_VALID)) {
  761. unsigned long tag;
  763. /* Spitfire Errata #32 workaround */
  764. __asm__ __volatile__("stxa %0, [%1] %2nt"
  765.      "flush %%g6"
  766.      : /* No outputs */
  767.      : "r" (0),
  768.      "r" (PRIMARY_CONTEXT), "i" (ASI_DMMU));
  770. tag = spitfire_get_dtlb_tag(i);
  771. if (save_p) {
  772. prom_dtlb[dtlb_seen].tlb_ent = i;
  773. prom_dtlb[dtlb_seen].tlb_tag = tag;
  774. prom_dtlb[dtlb_seen].tlb_data = data;
  775. }
  776. __asm__ __volatile__("stxa %%g0, [%0] %1nt"
  777.      "membar #Sync"
  778.      : : "r" (TLB_TAG_ACCESS), "i" (ASI_DMMU));
  779. spitfire_put_dtlb_data(i, 0x0UL);
  781. dtlb_seen++;
  782. if (dtlb_seen > 15)
  783. break;
  784. }
  785. }
  787. for (i = 0; i < high; i++) {
  788. unsigned long data;
  790. /* Spitfire Errata #32 workaround */
  791. __asm__ __volatile__("stxa %0, [%1] %2nt"
  792.      "flush %%g6"
  793.      : /* No outputs */
  794.      : "r" (0),
  795.      "r" (PRIMARY_CONTEXT), "i" (ASI_DMMU));
  797. data = spitfire_get_itlb_data(i);
  798. if ((data & (_PAGE_L|_PAGE_VALID)) == (_PAGE_L|_PAGE_VALID)) {
  799. unsigned long tag;
  801. /* Spitfire Errata #32 workaround */
  802. __asm__ __volatile__("stxa %0, [%1] %2nt"
  803.      "flush %%g6"
  804.      : /* No outputs */
  805.      : "r" (0),
  806.      "r" (PRIMARY_CONTEXT), "i" (ASI_DMMU));
  808. tag = spitfire_get_itlb_tag(i);
  809. if (save_p) {
  810. prom_itlb[itlb_seen].tlb_ent = i;
  811. prom_itlb[itlb_seen].tlb_tag = tag;
  812. prom_itlb[itlb_seen].tlb_data = data;
  813. }
  814. __asm__ __volatile__("stxa %%g0, [%0] %1nt"
  815.      "membar #Sync"
  816.      : : "r" (TLB_TAG_ACCESS), "i" (ASI_IMMU));
  817. spitfire_put_itlb_data(i, 0x0UL);
  819. itlb_seen++;
  820. if (itlb_seen > 15)
  821. break;
  822. }
  823. }
  824. } else if (tlb_type == cheetah || tlb_type == cheetah_plus) {
  825. int high = CHEETAH_HIGHEST_LOCKED_TLBENT - bigkernel;
  827. for (i = 0; i < high; i++) {
  828. unsigned long data;
  830. data = cheetah_get_ldtlb_data(i);
  831. if ((data & (_PAGE_L|_PAGE_VALID)) == (_PAGE_L|_PAGE_VALID)) {
  832. unsigned long tag;
  834. tag = cheetah_get_ldtlb_tag(i);
  835. if (save_p) {
  836. prom_dtlb[dtlb_seen].tlb_ent = i;
  837. prom_dtlb[dtlb_seen].tlb_tag = tag;
  838. prom_dtlb[dtlb_seen].tlb_data = data;
  839. }
  840. __asm__ __volatile__("stxa %%g0, [%0] %1nt"
  841.      "membar #Sync"
  842.      : : "r" (TLB_TAG_ACCESS), "i" (ASI_DMMU));
  843. cheetah_put_ldtlb_data(i, 0x0UL);
  845. dtlb_seen++;
  846. if (dtlb_seen > 15)
  847. break;
  848. }
  849. }
  851. for (i = 0; i < high; i++) {
  852. unsigned long data;
  854. data = cheetah_get_litlb_data(i);
  855. if ((data & (_PAGE_L|_PAGE_VALID)) == (_PAGE_L|_PAGE_VALID)) {
  856. unsigned long tag;
  858. tag = cheetah_get_litlb_tag(i);
  859. if (save_p) {
  860. prom_itlb[itlb_seen].tlb_ent = i;
  861. prom_itlb[itlb_seen].tlb_tag = tag;
  862. prom_itlb[itlb_seen].tlb_data = data;
  863. }
  864. __asm__ __volatile__("stxa %%g0, [%0] %1nt"
  865.      "membar #Sync"
  866.      : : "r" (TLB_TAG_ACCESS), "i" (ASI_IMMU));
  867. cheetah_put_litlb_data(i, 0x0UL);
  869. itlb_seen++;
  870. if (itlb_seen > 15)
  871. break;
  872. }
  873. }
  874. } else {
  875. /* Implement me :-) */
  876. BUG();
  877. }
  878. if (save_p)
  879. prom_ditlb_set = 1;
  880. }
  882. /* Give PROM back his world, done during reboots... */
  883. void prom_reload_locked(void)
  884. {
  885. int i;
  887. for (i = 0; i < 16; i++) {
  888. if (prom_dtlb[i].tlb_ent != -1) {
  889. __asm__ __volatile__("stxa %0, [%1] %2nt"
  890.      "membar #Sync"
  891. : : "r" (prom_dtlb[i].tlb_tag), "r" (TLB_TAG_ACCESS),
  892. "i" (ASI_DMMU));
  893. if (tlb_type == spitfire)
  894. spitfire_put_dtlb_data(prom_dtlb[i].tlb_ent,
  895.        prom_dtlb[i].tlb_data);
  896. else if (tlb_type == cheetah || tlb_type == cheetah_plus)
  897. cheetah_put_ldtlb_data(prom_dtlb[i].tlb_ent,
  898.       prom_dtlb[i].tlb_data);
  899. }
  901. if (prom_itlb[i].tlb_ent != -1) {
  902. __asm__ __volatile__("stxa %0, [%1] %2nt"
  903.      "membar #Sync"
  904.      : : "r" (prom_itlb[i].tlb_tag),
  905.      "r" (TLB_TAG_ACCESS),
  906.      "i" (ASI_IMMU));
  907. if (tlb_type == spitfire)
  908. spitfire_put_itlb_data(prom_itlb[i].tlb_ent,
  909.        prom_itlb[i].tlb_data);
  910. else
  911. cheetah_put_litlb_data(prom_itlb[i].tlb_ent,
  912.        prom_itlb[i].tlb_data);
  913. }
  914. }
  915. }
  917. void __flush_dcache_range(unsigned long start, unsigned long end)
  918. {
  919. unsigned long va;
  921. if (tlb_type == spitfire) {
  922. int n = 0;
  924. for (va = start; va < end; va += 32) {
  925. spitfire_put_dcache_tag(va & 0x3fe0, 0x0);
  926. if (++n >= 512)
  927. break;
  928. }
  929. } else {
  930. start = __pa(start);
  931. end = __pa(end);
  932. for (va = start; va < end; va += 32)
  933. __asm__ __volatile__("stxa %%g0, [%0] %1nt"
  934.      "membar #Sync"
  935.      : /* no outputs */
  936.      : "r" (va),
  937.        "i" (ASI_DCACHE_INVALIDATE));
  938. }
  939. }
  941. void __flush_cache_all(void)
  942. {
  943. /* Cheetah should be fine here too. */
  944. if (tlb_type == spitfire) {
  945. unsigned long va;
  947. flushw_all();
  948. for (va =  0; va < (PAGE_SIZE << 1); va += 32)
  949. spitfire_put_icache_tag(va, 0x0);
  950. __asm__ __volatile__("flush %g6");
  951. }
  952. }
  954. /* If not locked, zap it. */
  955. void __flush_tlb_all(void)
  956. {
  957. unsigned long pstate;
  958. int i;
  960. __asm__ __volatile__("flushwnt"
  961.      "rdpr %%pstate, %0nt"
  962.      "wrpr %0, %1, %%pstate"
  963.      : "=r" (pstate)
  964.      : "i" (PSTATE_IE));
  965. if (tlb_type == spitfire) {
  966. for (i = 0; i < 64; i++) {
  967. /* Spitfire Errata #32 workaround */
  968. __asm__ __volatile__("stxa %0, [%1] %2nt"
  969.      "flush %%g6"
  970.      : /* No outputs */
  971.      : "r" (0),
  972.      "r" (PRIMARY_CONTEXT), "i" (ASI_DMMU));
  974. if (!(spitfire_get_dtlb_data(i) & _PAGE_L)) {
  975. __asm__ __volatile__("stxa %%g0, [%0] %1nt"
  976.      "membar #Sync"
  977.      : /* no outputs */
  978.      : "r" (TLB_TAG_ACCESS), "i" (ASI_DMMU));
  979. spitfire_put_dtlb_data(i, 0x0UL);
  980. }
  982. /* Spitfire Errata #32 workaround */
  983. __asm__ __volatile__("stxa %0, [%1] %2nt"
  984.      "flush %%g6"
  985.      : /* No outputs */
  986.      : "r" (0),
  987.      "r" (PRIMARY_CONTEXT), "i" (ASI_DMMU));
  989. if (!(spitfire_get_itlb_data(i) & _PAGE_L)) {
  990. __asm__ __volatile__("stxa %%g0, [%0] %1nt"
  991.      "membar #Sync"
  992.      : /* no outputs */
  993.      : "r" (TLB_TAG_ACCESS), "i" (ASI_IMMU));
  994. spitfire_put_itlb_data(i, 0x0UL);
  995. }
  996. }
  997. } else if (tlb_type == cheetah || tlb_type == cheetah_plus) {
  998. cheetah_flush_dtlb_all();
  999. cheetah_flush_itlb_all();
  1000. }
  1001. __asm__ __volatile__("wrpr %0, 0, %%pstate"
  1002.      : : "r" (pstate));
  1003. }
  1005. /* Caller does TLB context flushing on local CPU if necessary.
  1006.  * The caller also ensures that CTX_VALID(mm->context) is false.
  1007.  *
  1008.  * We must be careful about boundary cases so that we never
  1009.  * let the user have CTX 0 (nucleus) or we ever use a CTX
  1010.  * version of zero (and thus NO_CONTEXT would not be caught
  1011.  * by version mis-match tests in mmu_context.h).
  1012.  */
  1013. void get_new_mmu_context(struct mm_struct *mm)
  1014. {
  1015. unsigned long ctx, new_ctx;
  1017. spin_lock(&ctx_alloc_lock);
  1018. ctx = CTX_HWBITS(tlb_context_cache + 1);
  1019. new_ctx = find_next_zero_bit(mmu_context_bmap, 1UL << CTX_VERSION_SHIFT, ctx);
  1020. if (new_ctx >= (1UL << CTX_VERSION_SHIFT)) {
  1021. new_ctx = find_next_zero_bit(mmu_context_bmap, ctx, 1);
  1022. if (new_ctx >= ctx) {
  1023. int i;
  1024. new_ctx = (tlb_context_cache & CTX_VERSION_MASK) +
  1025. CTX_FIRST_VERSION;
  1026. if (new_ctx == 1)
  1027. new_ctx = CTX_FIRST_VERSION;
  1029. /* Don't call memset, for 16 entries that's just
  1030.  * plain silly...
  1031.  */
  1032. mmu_context_bmap[0] = 3;
  1033. mmu_context_bmap[1] = 0;
  1034. mmu_context_bmap[2] = 0;
  1035. mmu_context_bmap[3] = 0;
  1036. for (i = 4; i < CTX_BMAP_SLOTS; i += 4) {
  1037. mmu_context_bmap[i + 0] = 0;
  1038. mmu_context_bmap[i + 1] = 0;
  1039. mmu_context_bmap[i + 2] = 0;
  1040. mmu_context_bmap[i + 3] = 0;
  1041. }
  1042. goto out;
  1043. }
  1044. }
  1045. mmu_context_bmap[new_ctx>>6] |= (1UL << (new_ctx & 63));
  1046. new_ctx |= (tlb_context_cache & CTX_VERSION_MASK);
  1047. out:
  1048. tlb_context_cache = new_ctx;
  1049. spin_unlock(&ctx_alloc_lock);
  1051. mm->context = new_ctx;
  1052. }
  1054. #ifndef CONFIG_SMP
  1055. struct pgtable_cache_struct pgt_quicklists;
  1056. #endif
  1058. /* OK, we have to color these pages. The page tables are accessed
  1059.  * by non-Dcache enabled mapping in the VPTE area by the dtlb_backend.S
  1060.  * code, as well as by PAGE_OFFSET range direct-mapped addresses by 
  1061.  * other parts of the kernel. By coloring, we make sure that the tlbmiss 
  1062.  * fast handlers do not get data from old/garbage dcache lines that 
  1063.  * correspond to an old/stale virtual address (user/kernel) that 
  1064.  * previously mapped the pagetable page while accessing vpte range 
  1065.  * addresses. The idea is that if the vpte color and PAGE_OFFSET range 
  1066.  * color is the same, then when the kernel initializes the pagetable 
  1067.  * using the later address range, accesses with the first address
  1068.  * range will see the newly initialized data rather than the garbage.
  1069.  */
  1070. #if (L1DCACHE_SIZE > PAGE_SIZE) /* is there D$ aliasing problem */
  1071. #define DC_ALIAS_SHIFT 1
  1072. #else
  1073. #define DC_ALIAS_SHIFT 0
  1074. #endif
  1075. pte_t *pte_alloc_one(struct mm_struct *mm, unsigned long address)
  1076. {
  1077. struct page *page = alloc_pages(GFP_KERNEL, DC_ALIAS_SHIFT);
  1078. unsigned long color = VPTE_COLOR(address);
  1080. if (page) {
  1081. unsigned long *to_free;
  1082. unsigned long paddr;
  1083. pte_t *pte;
  1085. #if (L1DCACHE_SIZE > PAGE_SIZE) /* is there D$ aliasing problem */
  1086. set_page_count((page + 1), 1);
  1087. #endif
  1088. paddr = (unsigned long) page_address(page);
  1089. memset((char *)paddr, 0, (PAGE_SIZE << DC_ALIAS_SHIFT));
  1091. if (!color) {
  1092. pte = (pte_t *) paddr;
  1093. to_free = (unsigned long *) (paddr + PAGE_SIZE);
  1094. } else {
  1095. pte = (pte_t *) (paddr + PAGE_SIZE);
  1096. to_free = (unsigned long *) paddr;
  1097. }
  1099. #if (L1DCACHE_SIZE > PAGE_SIZE) /* is there D$ aliasing problem */
  1100. /* Now free the other one up, adjust cache size. */
  1101. *to_free = (unsigned long) pte_quicklist[color ^ 0x1];
  1102. pte_quicklist[color ^ 0x1] = to_free;
  1103. pgtable_cache_size++;
  1104. #endif
  1106. return pte;
  1107. }
  1108. return NULL;
  1109. }
  1111. void sparc_ultra_dump_itlb(void)
  1112. {
  1113.         int slot;
  1115. if (tlb_type == spitfire) {
  1116. printk ("Contents of itlb: ");
  1117. for (slot = 0; slot < 14; slot++) printk ("    ");
  1118. printk ("%2x:%016lx,%016lxn",
  1119. 0,
  1120. spitfire_get_itlb_tag(0), spitfire_get_itlb_data(0));
  1121. for (slot = 1; slot < 64; slot+=3) {
  1122. printk ("%2x:%016lx,%016lx %2x:%016lx,%016lx %2x:%016lx,%016lxn", 
  1123. slot,
  1124. spitfire_get_itlb_tag(slot), spitfire_get_itlb_data(slot),
  1125. slot+1,
  1126. spitfire_get_itlb_tag(slot+1), spitfire_get_itlb_data(slot+1),
  1127. slot+2,
  1128. spitfire_get_itlb_tag(slot+2), spitfire_get_itlb_data(slot+2));
  1129. }
  1130. } else if (tlb_type == cheetah || tlb_type == cheetah_plus) {
  1131. printk ("Contents of itlb0:n");
  1132. for (slot = 0; slot < 16; slot+=2) {
  1133. printk ("%2x:%016lx,%016lx %2x:%016lx,%016lxn",
  1134. slot,
  1135. cheetah_get_litlb_tag(slot), cheetah_get_litlb_data(slot),
  1136. slot+1,
  1137. cheetah_get_litlb_tag(slot+1), cheetah_get_litlb_data(slot+1));
  1138. }
  1139. printk ("Contents of itlb2:n");
  1140. for (slot = 0; slot < 128; slot+=2) {
  1141. printk ("%2x:%016lx,%016lx %2x:%016lx,%016lxn",
  1142. slot,
  1143. cheetah_get_itlb_tag(slot), cheetah_get_itlb_data(slot),
  1144. slot+1,
  1145. cheetah_get_itlb_tag(slot+1), cheetah_get_itlb_data(slot+1));
  1146. }
  1147. }
  1148. }
  1150. void sparc_ultra_dump_dtlb(void)
  1151. {
  1152.         int slot;
  1154. if (tlb_type == spitfire) {
  1155. printk ("Contents of dtlb: ");
  1156. for (slot = 0; slot < 14; slot++) printk ("    ");
  1157. printk ("%2x:%016lx,%016lxn", 0,
  1158. spitfire_get_dtlb_tag(0), spitfire_get_dtlb_data(0));
  1159. for (slot = 1; slot < 64; slot+=3) {
  1160. printk ("%2x:%016lx,%016lx %2x:%016lx,%016lx %2x:%016lx,%016lxn", 
  1161. slot,
  1162. spitfire_get_dtlb_tag(slot), spitfire_get_dtlb_data(slot),
  1163. slot+1,
  1164. spitfire_get_dtlb_tag(slot+1), spitfire_get_dtlb_data(slot+1),
  1165. slot+2,
  1166. spitfire_get_dtlb_tag(slot+2), spitfire_get_dtlb_data(slot+2));
  1167. }
  1168. } else if (tlb_type == cheetah || tlb_type == cheetah_plus) {
  1169. printk ("Contents of dtlb0:n");
  1170. for (slot = 0; slot < 16; slot+=2) {
  1171. printk ("%2x:%016lx,%016lx %2x:%016lx,%016lxn",
  1172. slot,
  1173. cheetah_get_ldtlb_tag(slot), cheetah_get_ldtlb_data(slot),
  1174. slot+1,
  1175. cheetah_get_ldtlb_tag(slot+1), cheetah_get_ldtlb_data(slot+1));
  1176. }
  1177. printk ("Contents of dtlb2:n");
  1178. for (slot = 0; slot < 512; slot+=2) {
  1179. printk ("%2x:%016lx,%016lx %2x:%016lx,%016lxn",
  1180. slot,
  1181. cheetah_get_dtlb_tag(slot, 2), cheetah_get_dtlb_data(slot, 2),
  1182. slot+1,
  1183. cheetah_get_dtlb_tag(slot+1, 2), cheetah_get_dtlb_data(slot+1, 2));
  1184. }
  1185. if (tlb_type == cheetah_plus) {
  1186. printk ("Contents of dtlb3:n");
  1187. for (slot = 0; slot < 512; slot+=2) {
  1188. printk ("%2x:%016lx,%016lx %2x:%016lx,%016lxn",
  1189. slot,
  1190. cheetah_get_dtlb_tag(slot, 3), cheetah_get_dtlb_data(slot, 3),
  1191. slot+1,
  1192. cheetah_get_dtlb_tag(slot+1, 3), cheetah_get_dtlb_data(slot+1, 3));
  1193. }
  1194. }
  1195. }
  1196. }
  1198. extern unsigned long cmdline_memory_size;
  1200. unsigned long __init bootmem_init(unsigned long *pages_avail)
  1201. {
  1202. unsigned long bootmap_size, start_pfn, end_pfn;
  1203. unsigned long end_of_phys_memory = 0UL;
  1204. unsigned long bootmap_pfn, bytes_avail, size;
  1205. int i;
  1207. bytes_avail = 0UL;
  1208. for (i = 0; sp_banks[i].num_bytes != 0; i++) {
  1209. end_of_phys_memory = sp_banks[i].base_addr +
  1210. sp_banks[i].num_bytes;
  1211. bytes_avail += sp_banks[i].num_bytes;
  1212. if (cmdline_memory_size) {
  1213. if (bytes_avail > cmdline_memory_size) {
  1214. unsigned long slack = bytes_avail - cmdline_memory_size;
  1216. bytes_avail -= slack;
  1217. end_of_phys_memory -= slack;
  1219. sp_banks[i].num_bytes -= slack;
  1220. if (sp_banks[i].num_bytes == 0) {
  1221. sp_banks[i].base_addr = 0xdeadbeef;
  1222. } else {
  1223. sp_banks[i+1].num_bytes = 0;
  1224. sp_banks[i+1].base_addr = 0xdeadbeef;
  1225. }
  1226. break;
  1227. }
  1228. }
  1229. }
  1231. *pages_avail = bytes_avail >> PAGE_SHIFT;
  1233. /* Start with page aligned address of last symbol in kernel
  1234.  * image.  The kernel is hard mapped below PAGE_OFFSET in a
  1235.  * 4MB locked TLB translation.
  1236.  */
  1237. start_pfn  = PAGE_ALIGN((unsigned long) &_end) -
  1238. ((unsigned long) KERNBASE);
  1240. /* Adjust up to the physical address where the kernel begins. */
  1241. start_pfn += phys_base;
  1243. /* Now shift down to get the real physical page frame number. */
  1244. start_pfn >>= PAGE_SHIFT;
  1246. bootmap_pfn = start_pfn;
  1248. end_pfn = end_of_phys_memory >> PAGE_SHIFT;
  1250. #ifdef CONFIG_BLK_DEV_INITRD
  1251. /* Now have to check initial ramdisk, so that bootmap does not overwrite it */
  1252. if (sparc_ramdisk_image) {
  1253. if (sparc_ramdisk_image >= (unsigned long)&_end - 2 * PAGE_SIZE)
  1254. sparc_ramdisk_image -= KERNBASE;
  1255. initrd_start = sparc_ramdisk_image + phys_base;
  1256. initrd_end = initrd_start + sparc_ramdisk_size;
  1257. if (initrd_end > end_of_phys_memory) {
  1258. printk(KERN_CRIT "initrd extends beyond end of memory "
  1259.                    "(0x%016lx > 0x%016lx)ndisabling initrdn",
  1260.        initrd_end, end_of_phys_memory);
  1261. initrd_start = 0;
  1262. }
  1263. if (initrd_start) {
  1264. if (initrd_start >= (start_pfn << PAGE_SHIFT) &&
  1265.     initrd_start < (start_pfn << PAGE_SHIFT) + 2 * PAGE_SIZE)
  1266. bootmap_pfn = PAGE_ALIGN (initrd_end) >> PAGE_SHIFT;
  1267. }
  1268. }
  1269. #endif
  1270. /* Initialize the boot-time allocator. */
  1271. max_pfn = max_low_pfn = end_pfn;
  1272. min_low_pfn = phys_base >> PAGE_SHIFT;
  1273. bootmap_size = init_bootmem_node(NODE_DATA(0), bootmap_pfn, phys_base>>PAGE_SHIFT, end_pfn);
  1275. /* Now register the available physical memory with the
  1276.  * allocator.
  1277.  */
  1278. for (i = 0; sp_banks[i].num_bytes != 0; i++)
  1279. free_bootmem(sp_banks[i].base_addr,
  1280.      sp_banks[i].num_bytes);
  1282. #ifdef CONFIG_BLK_DEV_INITRD
  1283. if (initrd_start) {
  1284. size = initrd_end - initrd_start;
  1286. /* Resert the initrd image area. */
  1287. reserve_bootmem(initrd_start, size);
  1288. *pages_avail -= PAGE_ALIGN(size) >> PAGE_SHIFT;
  1290. initrd_start += PAGE_OFFSET;
  1291. initrd_end += PAGE_OFFSET;
  1292. }
  1293. #endif
  1294. /* Reserve the kernel text/data/bss. */
  1295. size = (start_pfn << PAGE_SHIFT) - phys_base;
  1296. reserve_bootmem(phys_base, size);
  1297. *pages_avail -= PAGE_ALIGN(size) >> PAGE_SHIFT;
  1299. /* Reserve the bootmem map.   We do not account for it
  1300.  * in pages_avail because we will release that memory
  1301.  * in free_all_bootmem.
  1302.  */
  1303. size = bootmap_size;
  1304. reserve_bootmem((bootmap_pfn << PAGE_SHIFT), size);
  1305. *pages_avail -= PAGE_ALIGN(size) >> PAGE_SHIFT;
  1307. return end_pfn;
  1308. }
  1310. /* paging_init() sets up the page tables */
  1312. extern void sun_serial_setup(void);
  1313. extern void cheetah_ecache_flush_init(void);
  1315. static unsigned long last_valid_pfn;
  1317. void __init paging_init(void)
  1318. {
  1319. extern pmd_t swapper_pmd_dir[1024];
  1320. extern unsigned int sparc64_vpte_patchme1[1];
  1321. extern unsigned int sparc64_vpte_patchme2[1];
  1322. unsigned long alias_base = phys_base + PAGE_OFFSET;
  1323. unsigned long second_alias_page = 0;
  1324. unsigned long pt, flags, end_pfn, pages_avail;
  1325. unsigned long shift = alias_base - ((unsigned long)KERNBASE);
  1326. unsigned long real_end;
  1328. set_bit(0, mmu_context_bmap);
  1330. real_end = (unsigned long)&_end;
  1331. if ((real_end > ((unsigned long)KERNBASE + 0x400000)))
  1332. bigkernel = 1;
  1333. #ifdef CONFIG_BLK_DEV_INITRD
  1334. if (sparc_ramdisk_image)
  1335. real_end = (PAGE_ALIGN(real_end) + PAGE_ALIGN(sparc_ramdisk_size));
  1336. #endif
  1338. /* We assume physical memory starts at some 4mb multiple,
  1339.  * if this were not true we wouldn't boot up to this point
  1340.  * anyways.
  1341.  */
  1342. pt  = phys_base | _PAGE_VALID | _PAGE_SZ4MB;
  1343. pt |= _PAGE_CP | _PAGE_CV | _PAGE_P | _PAGE_L | _PAGE_W;
  1344. __save_and_cli(flags);
  1345. if (tlb_type == spitfire) {
  1346. __asm__ __volatile__(
  1347. " stxa %1, [%0] %3n"
  1348. " stxa %2, [%5] %4n"
  1349. " membar #Syncn"
  1350. " flush %%g6n"
  1351. " nopn"
  1352. " nopn"
  1353. " nopn"
  1354. : /* No outputs */
  1355. : "r" (TLB_TAG_ACCESS), "r" (alias_base), "r" (pt),
  1356.   "i" (ASI_DMMU), "i" (ASI_DTLB_DATA_ACCESS), "r" (61 << 3)
  1357. : "memory");
  1358. if (real_end >= KERNBASE + 0x340000) {
  1359. second_alias_page = alias_base + 0x400000;
  1360. __asm__ __volatile__(
  1361. " stxa %1, [%0] %3n"
  1362. " stxa %2, [%5] %4n"
  1363. " membar #Syncn"
  1364. " flush %%g6n"
  1365. " nopn"
  1366. " nopn"
  1367. " nopn"
  1368. : /* No outputs */
  1369. : "r" (TLB_TAG_ACCESS), "r" (second_alias_page), "r" (pt + 0x400000),
  1370.   "i" (ASI_DMMU), "i" (ASI_DTLB_DATA_ACCESS), "r" (60 << 3)
  1371. : "memory");
  1372. }
  1373. } else if (tlb_type == cheetah || tlb_type == cheetah_plus) {
  1374. __asm__ __volatile__(
  1375. " stxa %1, [%0] %3n"
  1376. " stxa %2, [%5] %4n"
  1377. " membar #Syncn"
  1378. " flush %%g6n"
  1379. " nopn"
  1380. " nopn"
  1381. " nopn"
  1382. : /* No outputs */
  1383. : "r" (TLB_TAG_ACCESS), "r" (alias_base), "r" (pt),
  1384.   "i" (ASI_DMMU), "i" (ASI_DTLB_DATA_ACCESS), "r" ((0<<16) | (13<<3))
  1385. : "memory");
  1386. if (real_end >= KERNBASE + 0x340000) {
  1387. second_alias_page = alias_base + 0x400000;
  1388. __asm__ __volatile__(
  1389. " stxa %1, [%0] %3n"
  1390. " stxa %2, [%5] %4n"
  1391. " membar #Syncn"
  1392. " flush %%g6n"
  1393. " nopn"
  1394. " nopn"
  1395. " nopn"
  1396. : /* No outputs */
  1397. : "r" (TLB_TAG_ACCESS), "r" (second_alias_page), "r" (pt + 0x400000),
  1398.   "i" (ASI_DMMU), "i" (ASI_DTLB_DATA_ACCESS), "r" ((0<<16) | (12<<3))
  1399. : "memory");
  1400. }
  1401. }
  1402. __restore_flags(flags);
  1404. /* Now set kernel pgd to upper alias so physical page computations
  1405.  * work.
  1406.  */
  1407. init_mm.pgd += ((shift) / (sizeof(pgd_t)));
  1409. memset(swapper_pmd_dir, 0, sizeof(swapper_pmd_dir));
  1411. /* Now can init the kernel/bad page tables. */
  1412. pgd_set(&swapper_pg_dir[0], swapper_pmd_dir + (shift / sizeof(pgd_t)));
  1414. sparc64_vpte_patchme1[0] |= (pgd_val(init_mm.pgd[0]) >> 10);
  1415. sparc64_vpte_patchme2[0] |= (pgd_val(init_mm.pgd[0]) & 0x3ff);
  1416. flushi((long)&sparc64_vpte_patchme1[0]);
  1418. /* Setup bootmem... */
  1419. pages_avail = 0;
  1420. last_valid_pfn = end_pfn = bootmem_init(&pages_avail);
  1422. #ifdef CONFIG_SUN_SERIAL
  1423. /* This does not logically belong here, but we need to
  1424.  * call it at the moment we are able to use the bootmem
  1425.  * allocator.
  1426.  */
  1427. sun_serial_setup();
  1428. #endif
  1430. /* Inherit non-locked OBP mappings. */
  1431. inherit_prom_mappings();
  1433. /* Ok, we can use our TLB miss and window trap handlers safely.
  1434.  * We need to do a quick peek here to see if we are on StarFire
  1435.  * or not, so setup_tba can setup the IRQ globals correctly (it
  1436.  * needs to get the hard smp processor id correctly).
  1437.  */
  1438. {
  1439. extern void setup_tba(int);
  1440. setup_tba(this_is_starfire);
  1441. }
  1443. inherit_locked_prom_mappings(1);
  1445. /* We only created DTLB mapping of this stuff. */
  1446. spitfire_flush_dtlb_nucleus_page(alias_base);
  1447. if (second_alias_page)
  1448. spitfire_flush_dtlb_nucleus_page(second_alias_page);
  1450. __flush_tlb_all();
  1452. {
  1453. unsigned long zones_size[MAX_NR_ZONES];
  1454. unsigned long zholes_size[MAX_NR_ZONES];
  1455. unsigned long npages;
  1456. int znum;
  1458. for (znum = 0; znum < MAX_NR_ZONES; znum++)
  1459. zones_size[znum] = zholes_size[znum] = 0;
  1461. npages = end_pfn - (phys_base >> PAGE_SHIFT);
  1462. zones_size[ZONE_DMA] = npages;
  1463. zholes_size[ZONE_DMA] = npages - pages_avail;
  1465. free_area_init_node(0, NULL, NULL, zones_size,
  1466.     phys_base, zholes_size);
  1467. }
  1469. device_scan();
  1470. }
  1472. /* Ok, it seems that the prom can allocate some more memory chunks
  1473.  * as a side effect of some prom calls we perform during the
  1474.  * boot sequence.  My most likely theory is that it is from the
  1475.  * prom_set_traptable() call, and OBP is allocating a scratchpad
  1476.  * for saving client program register state etc.
  1477.  */
  1478. void __init sort_memlist(struct linux_mlist_p1275 *thislist)
  1479. {
  1480. int swapi = 0;
  1481. int i, mitr;
  1482. unsigned long tmpaddr, tmpsize;
  1483. unsigned long lowest;
  1485. for (i = 0; thislist[i].theres_more != 0; i++) {
  1486. lowest = thislist[i].start_adr;
  1487. for (mitr = i+1; thislist[mitr-1].theres_more != 0; mitr++)
  1488. if (thislist[mitr].start_adr < lowest) {
  1489. lowest = thislist[mitr].start_adr;
  1490. swapi = mitr;
  1491. }
  1492. if (lowest == thislist[i].start_adr)
  1493. continue;
  1494. tmpaddr = thislist[swapi].start_adr;
  1495. tmpsize = thislist[swapi].num_bytes;
  1496. for (mitr = swapi; mitr > i; mitr--) {
  1497. thislist[mitr].start_adr = thislist[mitr-1].start_adr;
  1498. thislist[mitr].num_bytes = thislist[mitr-1].num_bytes;
  1499. }
  1500. thislist[i].start_adr = tmpaddr;
  1501. thislist[i].num_bytes = tmpsize;
  1502. }
  1503. }
  1505. void __init rescan_sp_banks(void)
  1506. {
  1507. struct linux_prom64_registers memlist[64];
  1508. struct linux_mlist_p1275 avail[64], *mlist;
  1509. unsigned long bytes, base_paddr;
  1510. int num_regs, node = prom_finddevice("/memory");
  1511. int i;
  1513. num_regs = prom_getproperty(node, "available",
  1514.     (char *) memlist, sizeof(memlist));
  1515. num_regs = (num_regs / sizeof(struct linux_prom64_registers));
  1516. for (i = 0; i < num_regs; i++) {
  1517. avail[i].start_adr = memlist[i].phys_addr;
  1518. avail[i].num_bytes = memlist[i].reg_size;
  1519. avail[i].theres_more = &avail[i + 1];
  1520. }
  1521. avail[i - 1].theres_more = NULL;
  1522. sort_memlist(avail);
  1524. mlist = &avail[0];
  1525. i = 0;
  1526. bytes = mlist->num_bytes;
  1527. base_paddr = mlist->start_adr;
  1528.   
  1529. sp_banks[0].base_addr = base_paddr;
  1530. sp_banks[0].num_bytes = bytes;
  1532. while (mlist->theres_more != NULL){
  1533. i++;
  1534. mlist = mlist->theres_more;
  1535. bytes = mlist->num_bytes;
  1536. if (i >= SPARC_PHYS_BANKS-1) {
  1537. printk ("The machine has more banks than "
  1538. "this kernel can supportn"
  1539. "Increase the SPARC_PHYS_BANKS "
  1540. "setting (currently %d)n",
  1541. SPARC_PHYS_BANKS);
  1542. i = SPARC_PHYS_BANKS-1;
  1543. break;
  1544. }
  1545.     
  1546. sp_banks[i].base_addr = mlist->start_adr;
  1547. sp_banks[i].num_bytes = mlist->num_bytes;
  1548. }
  1550. i++;
  1551. sp_banks[i].base_addr = 0xdeadbeefbeefdeadUL;
  1552. sp_banks[i].num_bytes = 0;
  1554. for (i = 0; sp_banks[i].num_bytes != 0; i++)
  1555. sp_banks[i].num_bytes &= PAGE_MASK;
  1556. }
  1558. static void __init taint_real_pages(void)
  1559. {
  1560. struct sparc_phys_banks saved_sp_banks[SPARC_PHYS_BANKS];
  1561. int i;
  1563. for (i = 0; i < SPARC_PHYS_BANKS; i++) {
  1564. saved_sp_banks[i].base_addr =
  1565. sp_banks[i].base_addr;
  1566. saved_sp_banks[i].num_bytes =
  1567. sp_banks[i].num_bytes;
  1568. }
  1570. rescan_sp_banks();
  1572. /* Find changes discovered in the sp_bank rescan and
  1573.  * reserve the lost portions in the bootmem maps.
  1574.  */
  1575. for (i = 0; saved_sp_banks[i].num_bytes; i++) {
  1576. unsigned long old_start, old_end;
  1578. old_start = saved_sp_banks[i].base_addr;
  1579. old_end = old_start +
  1580. saved_sp_banks[i].num_bytes;
  1581. while (old_start < old_end) {
  1582. int n;
  1584. for (n = 0; sp_banks[n].num_bytes; n++) {
  1585. unsigned long new_start, new_end;
  1587. new_start = sp_banks[n].base_addr;
  1588. new_end = new_start + sp_banks[n].num_bytes;
  1590. if (new_start <= old_start &&
  1591.     new_end >= (old_start + PAGE_SIZE)) {
  1592. set_bit (old_start >> 22,
  1593.  sparc64_valid_addr_bitmap);
  1594. goto do_next_page;
  1595. }
  1596. }
  1597. reserve_bootmem(old_start, PAGE_SIZE);
  1599. do_next_page:
  1600. old_start += PAGE_SIZE;
  1601. }
  1602. }
  1603. }
  1605. void __init mem_init(void)
  1606. {
  1607. unsigned long codepages, datapages, initpages;
  1608. unsigned long addr, last;
  1609. int i;
  1611. i = last_valid_pfn >> ((22 - PAGE_SHIFT) + 6);
  1612. i += 1;
  1613. sparc64_valid_addr_bitmap = (unsigned long *)
  1614. __alloc_bootmem(i << 3, SMP_CACHE_BYTES, 0UL);
  1615. if (sparc64_valid_addr_bitmap == NULL) {
  1616. prom_printf("mem_init: Cannot alloc valid_addr_bitmap.n");
  1617. prom_halt();
  1618. }
  1619. memset(sparc64_valid_addr_bitmap, 0, i << 3);
  1621. addr = PAGE_OFFSET + phys_base;
  1622. last = PAGE_ALIGN((unsigned long)&_end) -
  1623. ((unsigned long) KERNBASE);
  1624. last += PAGE_OFFSET + phys_base;
  1625. while (addr < last) {
  1626. set_bit(__pa(addr) >> 22, sparc64_valid_addr_bitmap);
  1627. addr += PAGE_SIZE;
  1628. }
  1630. taint_real_pages();
  1632. max_mapnr = last_valid_pfn - (phys_base >> PAGE_SHIFT);
  1633. high_memory = __va(last_valid_pfn << PAGE_SHIFT);
  1635. num_physpages = free_all_bootmem() - 1;
  1637. /*
  1638.  * Set up the zero page, mark it reserved, so that page count
  1639.  * is not manipulated when freeing the page from user ptes.
  1640.  */
  1641. mem_map_zero = _alloc_pages(GFP_KERNEL, 0);
  1642. if (mem_map_zero == NULL) {
  1643. prom_printf("paging_init: Cannot alloc zero page.n");
  1644. prom_halt();
  1645. }
  1646. SetPageReserved(mem_map_zero);
  1647. clear_page(page_address(mem_map_zero));
  1649. codepages = (((unsigned long) &etext) - ((unsigned long)&_start));
  1650. codepages = PAGE_ALIGN(codepages) >> PAGE_SHIFT;
  1651. datapages = (((unsigned long) &edata) - ((unsigned long)&etext));
  1652. datapages = PAGE_ALIGN(datapages) >> PAGE_SHIFT;
  1653. initpages = (((unsigned long) &__init_end) - ((unsigned long) &__init_begin));
  1654. initpages = PAGE_ALIGN(initpages) >> PAGE_SHIFT;
  1656. #ifndef CONFIG_SMP
  1657. {
  1658. /* Put empty_pg_dir on pgd_quicklist */
  1659. extern pgd_t empty_pg_dir[1024];
  1660. unsigned long addr = (unsigned long)empty_pg_dir;
  1661. unsigned long alias_base = phys_base + PAGE_OFFSET -
  1662. (long)(KERNBASE);
  1664. memset(empty_pg_dir, 0, sizeof(empty_pg_dir));
  1665. addr += alias_base;
  1666. free_pgd_fast((pgd_t *)addr);
  1667. num_physpages++;
  1668. }
  1669. #endif
  1671. printk("Memory: %uk available (%ldk kernel code, %ldk data, %ldk init) [%016lx,%016lx]n",
  1672.        nr_free_pages() << (PAGE_SHIFT-10),
  1673.        codepages << (PAGE_SHIFT-10),
  1674.        datapages << (PAGE_SHIFT-10), 
  1675.        initpages << (PAGE_SHIFT-10), 
  1676.        PAGE_OFFSET, (last_valid_pfn << PAGE_SHIFT));
  1678. if (tlb_type == cheetah || tlb_type == cheetah_plus)
  1679. cheetah_ecache_flush_init();
  1680. }
  1682. void free_initmem (void)
  1683. {
  1684. unsigned long addr, initend;
  1686. /*
  1687.  * The init section is aligned to 8k in vmlinux.lds. Page align for >8k pagesizes.
  1688.  */
  1689. addr = PAGE_ALIGN((unsigned long)(&__init_begin));
  1690. initend = (unsigned long)(&__init_end) & PAGE_MASK;
  1691. for (; addr < initend; addr += PAGE_SIZE) {
  1692. unsigned long page;
  1693. struct page *p;
  1695. page = (addr +
  1696. ((unsigned long) __va(phys_base)) -
  1697. ((unsigned long) KERNBASE));
  1698. p = virt_to_page(page);
  1700. ClearPageReserved(p);
  1701. set_page_count(p, 1);
  1702. __free_page(p);
  1703. num_physpages++;
  1704. }
  1705. }
  1707. #ifdef CONFIG_BLK_DEV_INITRD
  1708. void free_initrd_mem(unsigned long start, unsigned long end)
  1709. {
  1710. if (start < end)
  1711. printk ("Freeing initrd memory: %ldk freedn", (end - start) >> 10);
  1712. for (; start < end; start += PAGE_SIZE) {
  1713. struct page *p = virt_to_page(start);
  1715. ClearPageReserved(p);
  1716. set_page_count(p, 1);
  1717. __free_page(p);
  1718. num_physpages++;
  1719. }
  1720. }
  1721. #endif
  1723. void si_meminfo(struct sysinfo *val)
  1724. {
  1725. val->totalram = num_physpages;
  1726. val->sharedram = 0;
  1727. val->freeram = nr_free_pages();
  1728. val->bufferram = atomic_read(&buffermem_pages);
  1730. /* These are always zero on Sparc64. */
  1731. val->totalhigh = 0;
  1732. val->freehigh = 0;
  1734. val->mem_unit = PAGE_SIZE;
  1735. }