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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
init.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：47k
源码类别：

嵌入式Linux

开发平台：

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 == spitfire)
  262. seq_printf(m, "MMU Typet: Spitfiren");
  263. else
  264. seq_printf(m, "MMU Typet: ???n");
  266. #ifdef CONFIG_DEBUG_DCFLUSH
  267. seq_printf(m, "DCPageFlushest: %dn",
  268.    atomic_read(&dcpage_flushes));
  269. #ifdef CONFIG_SMP
  270. seq_printf(m, "DCPageFlushesXCt: %dn",
  271.    atomic_read(&dcpage_flushes_xcall));
  272. #endif /* CONFIG_SMP */
  273. #endif /* CONFIG_DEBUG_DCFLUSH */
  274. }
  276. struct linux_prom_translation {
  277. unsigned long virt;
  278. unsigned long size;
  279. unsigned long data;
  280. };
  282. extern unsigned long prom_boot_page;
  283. extern void prom_remap(unsigned long physpage, unsigned long virtpage, int mmu_ihandle);
  284. extern int prom_get_mmu_ihandle(void);
  285. extern void register_prom_callbacks(void);
  287. /* Exported for SMP bootup purposes. */
  288. unsigned long kern_locked_tte_data;
  290. void __init early_pgtable_allocfail(char *type)
  291. {
  292. prom_printf("inherit_prom_mappings: Cannot alloc kernel %s.n", type);
  293. prom_halt();
  294. }
  296. #define BASE_PAGE_SIZE 8192
  297. static pmd_t *prompmd;
  299. /*
  300.  * Translate PROM's mapping we capture at boot time into physical address.
  301.  * The second parameter is only set from prom_callback() invocations.
  302.  */
  303. unsigned long prom_virt_to_phys(unsigned long promva, int *error)
  304. {
  305. pmd_t *pmdp = prompmd + ((promva >> 23) & 0x7ff);
  306. pte_t *ptep;
  307. unsigned long base;
  309. if (pmd_none(*pmdp)) {
  310. if (error)
  311. *error = 1;
  312. return(0);
  313. }
  314. ptep = (pte_t *)pmd_page(*pmdp) + ((promva >> 13) & 0x3ff);
  315. if (!pte_present(*ptep)) {
  316. if (error)
  317. *error = 1;
  318. return(0);
  319. }
  320. if (error) {
  321. *error = 0;
  322. return(pte_val(*ptep));
  323. }
  324. base = pte_val(*ptep) & _PAGE_PADDR;
  325. return(base + (promva & (BASE_PAGE_SIZE - 1)));
  326. }
  328. static void inherit_prom_mappings(void)
  329. {
  330. struct linux_prom_translation *trans;
  331. unsigned long phys_page, tte_vaddr, tte_data;
  332. void (*remap_func)(unsigned long, unsigned long, int);
  333. pmd_t *pmdp;
  334. pte_t *ptep;
  335. int node, n, i, tsz;
  336. extern unsigned int obp_iaddr_patch[2], obp_daddr_patch[2];
  338. node = prom_finddevice("/virtual-memory");
  339. n = prom_getproplen(node, "translations");
  340. if (n == 0 || n == -1) {
  341. prom_printf("Couldn't get translation propertyn");
  342. prom_halt();
  343. }
  344. n += 5 * sizeof(struct linux_prom_translation);
  345. for (tsz = 1; tsz < n; tsz <<= 1)
  346. /* empty */;
  347. trans = __alloc_bootmem(tsz, SMP_CACHE_BYTES, 0UL);
  348. if (trans == NULL) {
  349. prom_printf("inherit_prom_mappings: Cannot alloc translations.n");
  350. prom_halt();
  351. }
  352. memset(trans, 0, tsz);
  354. if ((n = prom_getproperty(node, "translations", (char *)trans, tsz)) == -1) {
  355. prom_printf("Couldn't get translation propertyn");
  356. prom_halt();
  357. }
  358. n = n / sizeof(*trans);
  360. /*
  361.  * The obp translations are saved based on 8k pagesize, since obp can use
  362.  * a mixture of pagesizes. Misses to the 0xf0000000 - 0x100000000, ie obp 
  363.  * range, are handled in entry.S and do not use the vpte scheme (see rant
  364.  * in inherit_locked_prom_mappings()).
  365.  */
  366. #define OBP_PMD_SIZE 2048
  367. prompmd = __alloc_bootmem(OBP_PMD_SIZE, OBP_PMD_SIZE, 0UL);
  368. if (prompmd == NULL)
  369. early_pgtable_allocfail("pmd");
  370. memset(prompmd, 0, OBP_PMD_SIZE);
  371. for (i = 0; i < n; i++) {
  372. unsigned long vaddr;
  374. if (trans[i].virt >= LOW_OBP_ADDRESS && trans[i].virt < HI_OBP_ADDRESS) {
  375. for (vaddr = trans[i].virt;
  376.      ((vaddr < trans[i].virt + trans[i].size) && 
  377.      (vaddr < HI_OBP_ADDRESS));
  378.      vaddr += BASE_PAGE_SIZE) {
  379. unsigned long val;
  381. pmdp = prompmd + ((vaddr >> 23) & 0x7ff);
  382. if (pmd_none(*pmdp)) {
  383. ptep = __alloc_bootmem(BASE_PAGE_SIZE,
  384.        BASE_PAGE_SIZE,
  385.        0UL);
  386. if (ptep == NULL)
  387. early_pgtable_allocfail("pte");
  388. memset(ptep, 0, BASE_PAGE_SIZE);
  389. pmd_set(pmdp, ptep);
  390. }
  391. ptep = (pte_t *)pmd_page(*pmdp) +
  392. ((vaddr >> 13) & 0x3ff);
  394. val = trans[i].data;
  396. /* Clear diag TTE bits. */
  397. if (tlb_type == spitfire)
  398. val &= ~0x0003fe0000000000UL;
  400. set_pte (ptep, __pte(val | _PAGE_MODIFIED));
  401. trans[i].data += BASE_PAGE_SIZE;
  402. }
  403. }
  404. }
  405. phys_page = __pa(prompmd);
  406. obp_iaddr_patch[0] |= (phys_page >> 10);
  407. obp_iaddr_patch[1] |= (phys_page & 0x3ff);
  408. flushi((long)&obp_iaddr_patch[0]);
  409. obp_daddr_patch[0] |= (phys_page >> 10);
  410. obp_daddr_patch[1] |= (phys_page & 0x3ff);
  411. flushi((long)&obp_daddr_patch[0]);
  413. /* Now fixup OBP's idea about where we really are mapped. */
  414. prom_printf("Remapping the kernel... ");
  416. /* Spitfire Errata #32 workaround */
  417. __asm__ __volatile__("stxa %0, [%1] %2nt"
  418.      "flush %%g6"
  419.      : /* No outputs */
  420.      : "r" (0),
  421.      "r" (PRIMARY_CONTEXT), "i" (ASI_DMMU));
  423. switch (tlb_type) {
  424. default:
  425. case spitfire:
  426. phys_page = spitfire_get_dtlb_data(sparc64_highest_locked_tlbent());
  427. break;
  429. case cheetah:
  430. phys_page = cheetah_get_litlb_data(sparc64_highest_locked_tlbent());
  431. break;
  432. };
  434. phys_page &= _PAGE_PADDR;
  435. phys_page += ((unsigned long)&prom_boot_page -
  436.       (unsigned long)KERNBASE);
  438. if (tlb_type == spitfire) {
  439. /* Lock this into i/d tlb entry 59 */
  440. __asm__ __volatile__(
  441. "stxa %%g0, [%2] %3nt"
  442. "stxa %0, [%1] %4nt"
  443. "membar #Syncnt"
  444. "flush %%g6nt"
  445. "stxa %%g0, [%2] %5nt"
  446. "stxa %0, [%1] %6nt"
  447. "membar #Syncnt"
  448. "flush %%g6"
  449. : : "r" (phys_page | _PAGE_VALID | _PAGE_SZ8K | _PAGE_CP |
  450.  _PAGE_CV | _PAGE_P | _PAGE_L | _PAGE_W),
  451. "r" (59 << 3), "r" (TLB_TAG_ACCESS),
  452. "i" (ASI_DMMU), "i" (ASI_DTLB_DATA_ACCESS),
  453. "i" (ASI_IMMU), "i" (ASI_ITLB_DATA_ACCESS)
  454. : "memory");
  455. } else if (tlb_type == cheetah) {
  456. /* Lock this into i/d tlb-0 entry 11 */
  457. __asm__ __volatile__(
  458. "stxa %%g0, [%2] %3nt"
  459. "stxa %0, [%1] %4nt"
  460. "membar #Syncnt"
  461. "flush %%g6nt"
  462. "stxa %%g0, [%2] %5nt"
  463. "stxa %0, [%1] %6nt"
  464. "membar #Syncnt"
  465. "flush %%g6"
  466. : : "r" (phys_page | _PAGE_VALID | _PAGE_SZ8K | _PAGE_CP |
  467.  _PAGE_CV | _PAGE_P | _PAGE_L | _PAGE_W),
  468. "r" ((0 << 16) | (11 << 3)), "r" (TLB_TAG_ACCESS),
  469. "i" (ASI_DMMU), "i" (ASI_DTLB_DATA_ACCESS),
  470. "i" (ASI_IMMU), "i" (ASI_ITLB_DATA_ACCESS)
  471. : "memory");
  472. } else {
  473. /* Implement me :-) */
  474. BUG();
  475. }
  477. tte_vaddr = (unsigned long) KERNBASE;
  479. /* Spitfire Errata #32 workaround */
  480. __asm__ __volatile__("stxa %0, [%1] %2nt"
  481.      "flush %%g6"
  482.      : /* No outputs */
  483.      : "r" (0),
  484.      "r" (PRIMARY_CONTEXT), "i" (ASI_DMMU));
  486. if (tlb_type == spitfire)
  487. tte_data = spitfire_get_dtlb_data(sparc64_highest_locked_tlbent());
  488. else
  489. tte_data = cheetah_get_ldtlb_data(sparc64_highest_locked_tlbent());
  491. kern_locked_tte_data = tte_data;
  493. remap_func = (void *)  ((unsigned long) &prom_remap -
  494. (unsigned long) &prom_boot_page);
  497. /* Spitfire Errata #32 workaround */
  498. __asm__ __volatile__("stxa %0, [%1] %2nt"
  499.      "flush %%g6"
  500.      : /* No outputs */
  501.      : "r" (0),
  502.      "r" (PRIMARY_CONTEXT), "i" (ASI_DMMU));
  504. remap_func((tlb_type == spitfire ?
  505.     (spitfire_get_dtlb_data(sparc64_highest_locked_tlbent()) & _PAGE_PADDR) :
  506.     (cheetah_get_litlb_data(sparc64_highest_locked_tlbent()) & _PAGE_PADDR)),
  507.    (unsigned long) KERNBASE,
  508.    prom_get_mmu_ihandle());
  510. if (bigkernel)
  511. remap_func(((tte_data + 0x400000) & _PAGE_PADDR),
  512. (unsigned long) KERNBASE + 0x400000, prom_get_mmu_ihandle());
  514. /* Flush out that temporary mapping. */
  515. spitfire_flush_dtlb_nucleus_page(0x0);
  516. spitfire_flush_itlb_nucleus_page(0x0);
  518. /* Now lock us back into the TLBs via OBP. */
  519. prom_dtlb_load(sparc64_highest_locked_tlbent(), tte_data, tte_vaddr);
  520. prom_itlb_load(sparc64_highest_locked_tlbent(), tte_data, tte_vaddr);
  521. if (bigkernel) {
  522. prom_dtlb_load(sparc64_highest_locked_tlbent()-1, tte_data + 0x400000, 
  523. tte_vaddr + 0x400000);
  524. prom_itlb_load(sparc64_highest_locked_tlbent()-1, tte_data + 0x400000, 
  525. tte_vaddr + 0x400000);
  526. }
  528. /* Re-read translations property. */
  529. if ((n = prom_getproperty(node, "translations", (char *)trans, tsz)) == -1) {
  530. prom_printf("Couldn't get translation propertyn");
  531. prom_halt();
  532. }
  533. n = n / sizeof(*trans);
  535. for (i = 0; i < n; i++) {
  536. unsigned long vaddr = trans[i].virt;
  537. unsigned long size = trans[i].size;
  539. if (vaddr < 0xf0000000UL) {
  540. unsigned long avoid_start = (unsigned long) KERNBASE;
  541. unsigned long avoid_end = avoid_start + (4 * 1024 * 1024);
  543. if (bigkernel)
  544. avoid_end += (4 * 1024 * 1024);
  545. if (vaddr < avoid_start) {
  546. unsigned long top = vaddr + size;
  548. if (top > avoid_start)
  549. top = avoid_start;
  550. prom_unmap(top - vaddr, vaddr);
  551. }
  552. if ((vaddr + size) > avoid_end) {
  553. unsigned long bottom = vaddr;
  555. if (bottom < avoid_end)
  556. bottom = avoid_end;
  557. prom_unmap((vaddr + size) - bottom, bottom);
  558. }
  559. }
  560. }
  562. prom_printf("done.n");
  564. register_prom_callbacks();
  565. }
  567. /* The OBP specifications for sun4u mark 0xfffffffc00000000 and
  568.  * upwards as reserved for use by the firmware (I wonder if this
  569.  * will be the same on Cheetah...).  We use this virtual address
  570.  * range for the VPTE table mappings of the nucleus so we need
  571.  * to zap them when we enter the PROM.  -DaveM
  572.  */
  573. static void __flush_nucleus_vptes(void)
  574. {
  575. unsigned long prom_reserved_base = 0xfffffffc00000000UL;
  576. int i;
  578. /* Only DTLB must be checked for VPTE entries. */
  579. if (tlb_type == spitfire) {
  580. for (i = 0; i < 63; i++) {
  581. unsigned long tag;
  583. /* Spitfire Errata #32 workaround */
  584. __asm__ __volatile__("stxa %0, [%1] %2nt"
  585.      "flush %%g6"
  586.      : /* No outputs */
  587.      : "r" (0),
  588.      "r" (PRIMARY_CONTEXT), "i" (ASI_DMMU));
  590. tag = spitfire_get_dtlb_tag(i);
  591. if (((tag & ~(PAGE_MASK)) == 0) &&
  592.     ((tag &  (PAGE_MASK)) >= prom_reserved_base)) {
  593. __asm__ __volatile__("stxa %%g0, [%0] %1nt"
  594.      "membar #Sync"
  595.      : /* no outputs */
  596.      : "r" (TLB_TAG_ACCESS), "i" (ASI_DMMU));
  597. spitfire_put_dtlb_data(i, 0x0UL);
  598. }
  599. }
  600. } else if (tlb_type == cheetah) {
  601. for (i = 0; i < 512; i++) {
  602. unsigned long tag = cheetah_get_dtlb_tag(i);
  604. if ((tag & ~PAGE_MASK) == 0 &&
  605.     (tag & PAGE_MASK) >= prom_reserved_base) {
  606. __asm__ __volatile__("stxa %%g0, [%0] %1nt"
  607.      "membar #Sync"
  608.      : /* no outputs */
  609.      : "r" (TLB_TAG_ACCESS), "i" (ASI_DMMU));
  610. cheetah_put_dtlb_data(i, 0x0UL);
  611. }
  612. }
  613. } else {
  614. /* Implement me :-) */
  615. BUG();
  616. }
  617. }
  619. static int prom_ditlb_set = 0;
  620. struct prom_tlb_entry {
  621. int tlb_ent;
  622. unsigned long tlb_tag;
  623. unsigned long tlb_data;
  624. };
  625. struct prom_tlb_entry prom_itlb[16], prom_dtlb[16];
  627. void prom_world(int enter)
  628. {
  629. unsigned long pstate;
  630. int i;
  632. if (!enter)
  633. set_fs(current->thread.current_ds);
  635. if (!prom_ditlb_set)
  636. return;
  638. /* Make sure the following runs atomically. */
  639. __asm__ __volatile__("flushwnt"
  640.      "rdpr %%pstate, %0nt"
  641.      "wrpr %0, %1, %%pstate"
  642.      : "=r" (pstate)
  643.      : "i" (PSTATE_IE));
  645. if (enter) {
  646. /* Kick out nucleus VPTEs. */
  647. __flush_nucleus_vptes();
  649. /* Install PROM world. */
  650. for (i = 0; i < 16; i++) {
  651. if (prom_dtlb[i].tlb_ent != -1) {
  652. __asm__ __volatile__("stxa %0, [%1] %2nt"
  653.      "membar #Sync"
  654. : : "r" (prom_dtlb[i].tlb_tag), "r" (TLB_TAG_ACCESS),
  655. "i" (ASI_DMMU));
  656. if (tlb_type == spitfire)
  657. spitfire_put_dtlb_data(prom_dtlb[i].tlb_ent,
  658.        prom_dtlb[i].tlb_data);
  659. else if (tlb_type == cheetah)
  660. cheetah_put_ldtlb_data(prom_dtlb[i].tlb_ent,
  661.        prom_dtlb[i].tlb_data);
  662. }
  663. if (prom_itlb[i].tlb_ent != -1) {
  664. __asm__ __volatile__("stxa %0, [%1] %2nt"
  665.      "membar #Sync"
  666.      : : "r" (prom_itlb[i].tlb_tag),
  667.      "r" (TLB_TAG_ACCESS),
  668.      "i" (ASI_IMMU));
  669. if (tlb_type == spitfire)
  670. spitfire_put_itlb_data(prom_itlb[i].tlb_ent,
  671.        prom_itlb[i].tlb_data);
  672. else if (tlb_type == cheetah)
  673. cheetah_put_litlb_data(prom_itlb[i].tlb_ent,
  674.        prom_itlb[i].tlb_data);
  675. }
  676. }
  677. } else {
  678. for (i = 0; i < 16; i++) {
  679. if (prom_dtlb[i].tlb_ent != -1) {
  680. __asm__ __volatile__("stxa %%g0, [%0] %1nt"
  681.      "membar #Sync"
  682. : : "r" (TLB_TAG_ACCESS), "i" (ASI_DMMU));
  683. if (tlb_type == spitfire)
  684. spitfire_put_dtlb_data(prom_dtlb[i].tlb_ent, 0x0UL);
  685. else
  686. cheetah_put_ldtlb_data(prom_dtlb[i].tlb_ent, 0x0UL);
  687. }
  688. if (prom_itlb[i].tlb_ent != -1) {
  689. __asm__ __volatile__("stxa %%g0, [%0] %1nt"
  690.      "membar #Sync"
  691.      : : "r" (TLB_TAG_ACCESS),
  692.      "i" (ASI_IMMU));
  693. if (tlb_type == spitfire)
  694. spitfire_put_itlb_data(prom_itlb[i].tlb_ent, 0x0UL);
  695. else
  696. cheetah_put_litlb_data(prom_itlb[i].tlb_ent, 0x0UL);
  697. }
  698. }
  699. }
  700. __asm__ __volatile__("wrpr %0, 0, %%pstate"
  701.      : : "r" (pstate));
  702. }
  704. void inherit_locked_prom_mappings(int save_p)
  705. {
  706. int i;
  707. int dtlb_seen = 0;
  708. int itlb_seen = 0;
  710. /* Fucking losing PROM has more mappings in the TLB, but
  711.  * it (conveniently) fails to mention any of these in the
  712.  * translations property.  The only ones that matter are
  713.  * the locked PROM tlb entries, so we impose the following
  714.  * irrecovable rule on the PROM, it is allowed 8 locked
  715.  * entries in the ITLB and 8 in the DTLB.
  716.  *
  717.  * Supposedly the upper 16GB of the address space is
  718.  * reserved for OBP, BUT I WISH THIS WAS DOCUMENTED
  719.  * SOMEWHERE!!!!!!!!!!!!!!!!!  Furthermore the entire interface
  720.  * used between the client program and the firmware on sun5
  721.  * systems to coordinate mmu mappings is also COMPLETELY
  722.  * UNDOCUMENTED!!!!!! Thanks S(t)un!
  723.  */
  724. if (save_p) {
  725. for (i = 0; i < 16; i++) {
  726. prom_itlb[i].tlb_ent = -1;
  727. prom_dtlb[i].tlb_ent = -1;
  728. }
  729. }
  730. if (tlb_type == spitfire) {
  731. int high = SPITFIRE_HIGHEST_LOCKED_TLBENT - bigkernel;
  732. for (i = 0; i < high; i++) {
  733. unsigned long data;
  735. /* Spitfire Errata #32 workaround */
  736. __asm__ __volatile__("stxa %0, [%1] %2nt"
  737.      "flush %%g6"
  738.      : /* No outputs */
  739.      : "r" (0),
  740.      "r" (PRIMARY_CONTEXT), "i" (ASI_DMMU));
  742. data = spitfire_get_dtlb_data(i);
  743. if ((data & (_PAGE_L|_PAGE_VALID)) == (_PAGE_L|_PAGE_VALID)) {
  744. unsigned long tag;
  746. /* Spitfire Errata #32 workaround */
  747. __asm__ __volatile__("stxa %0, [%1] %2nt"
  748.      "flush %%g6"
  749.      : /* No outputs */
  750.      : "r" (0),
  751.      "r" (PRIMARY_CONTEXT), "i" (ASI_DMMU));
  753. tag = spitfire_get_dtlb_tag(i);
  754. if (save_p) {
  755. prom_dtlb[dtlb_seen].tlb_ent = i;
  756. prom_dtlb[dtlb_seen].tlb_tag = tag;
  757. prom_dtlb[dtlb_seen].tlb_data = data;
  758. }
  759. __asm__ __volatile__("stxa %%g0, [%0] %1nt"
  760.      "membar #Sync"
  761.      : : "r" (TLB_TAG_ACCESS), "i" (ASI_DMMU));
  762. spitfire_put_dtlb_data(i, 0x0UL);
  764. dtlb_seen++;
  765. if (dtlb_seen > 15)
  766. break;
  767. }
  768. }
  770. for (i = 0; i < high; i++) {
  771. unsigned long data;
  773. /* Spitfire Errata #32 workaround */
  774. __asm__ __volatile__("stxa %0, [%1] %2nt"
  775.      "flush %%g6"
  776.      : /* No outputs */
  777.      : "r" (0),
  778.      "r" (PRIMARY_CONTEXT), "i" (ASI_DMMU));
  780. data = spitfire_get_itlb_data(i);
  781. if ((data & (_PAGE_L|_PAGE_VALID)) == (_PAGE_L|_PAGE_VALID)) {
  782. unsigned long tag;
  784. /* Spitfire Errata #32 workaround */
  785. __asm__ __volatile__("stxa %0, [%1] %2nt"
  786.      "flush %%g6"
  787.      : /* No outputs */
  788.      : "r" (0),
  789.      "r" (PRIMARY_CONTEXT), "i" (ASI_DMMU));
  791. tag = spitfire_get_itlb_tag(i);
  792. if (save_p) {
  793. prom_itlb[itlb_seen].tlb_ent = i;
  794. prom_itlb[itlb_seen].tlb_tag = tag;
  795. prom_itlb[itlb_seen].tlb_data = data;
  796. }
  797. __asm__ __volatile__("stxa %%g0, [%0] %1nt"
  798.      "membar #Sync"
  799.      : : "r" (TLB_TAG_ACCESS), "i" (ASI_IMMU));
  800. spitfire_put_itlb_data(i, 0x0UL);
  802. itlb_seen++;
  803. if (itlb_seen > 15)
  804. break;
  805. }
  806. }
  807. } else if (tlb_type == cheetah) {
  808. int high = CHEETAH_HIGHEST_LOCKED_TLBENT - bigkernel;
  810. for (i = 0; i < high; i++) {
  811. unsigned long data;
  813. data = cheetah_get_ldtlb_data(i);
  814. if ((data & (_PAGE_L|_PAGE_VALID)) == (_PAGE_L|_PAGE_VALID)) {
  815. unsigned long tag;
  817. tag = cheetah_get_ldtlb_tag(i);
  818. if (save_p) {
  819. prom_dtlb[dtlb_seen].tlb_ent = i;
  820. prom_dtlb[dtlb_seen].tlb_tag = tag;
  821. prom_dtlb[dtlb_seen].tlb_data = data;
  822. }
  823. __asm__ __volatile__("stxa %%g0, [%0] %1nt"
  824.      "membar #Sync"
  825.      : : "r" (TLB_TAG_ACCESS), "i" (ASI_DMMU));
  826. cheetah_put_ldtlb_data(i, 0x0UL);
  828. dtlb_seen++;
  829. if (dtlb_seen > 15)
  830. break;
  831. }
  832. }
  834. for (i = 0; i < high; i++) {
  835. unsigned long data;
  837. data = cheetah_get_litlb_data(i);
  838. if ((data & (_PAGE_L|_PAGE_VALID)) == (_PAGE_L|_PAGE_VALID)) {
  839. unsigned long tag;
  841. tag = cheetah_get_litlb_tag(i);
  842. if (save_p) {
  843. prom_itlb[itlb_seen].tlb_ent = i;
  844. prom_itlb[itlb_seen].tlb_tag = tag;
  845. prom_itlb[itlb_seen].tlb_data = data;
  846. }
  847. __asm__ __volatile__("stxa %%g0, [%0] %1nt"
  848.      "membar #Sync"
  849.      : : "r" (TLB_TAG_ACCESS), "i" (ASI_IMMU));
  850. cheetah_put_litlb_data(i, 0x0UL);
  852. itlb_seen++;
  853. if (itlb_seen > 15)
  854. break;
  855. }
  856. }
  857. } else {
  858. /* Implement me :-) */
  859. BUG();
  860. }
  861. if (save_p)
  862. prom_ditlb_set = 1;
  863. }
  865. /* Give PROM back his world, done during reboots... */
  866. void prom_reload_locked(void)
  867. {
  868. int i;
  870. for (i = 0; i < 16; i++) {
  871. if (prom_dtlb[i].tlb_ent != -1) {
  872. __asm__ __volatile__("stxa %0, [%1] %2nt"
  873.      "membar #Sync"
  874. : : "r" (prom_dtlb[i].tlb_tag), "r" (TLB_TAG_ACCESS),
  875. "i" (ASI_DMMU));
  876. if (tlb_type == spitfire)
  877. spitfire_put_dtlb_data(prom_dtlb[i].tlb_ent,
  878.        prom_dtlb[i].tlb_data);
  879. else if (tlb_type == cheetah)
  880. cheetah_put_ldtlb_data(prom_dtlb[i].tlb_ent,
  881.       prom_dtlb[i].tlb_data);
  882. }
  884. if (prom_itlb[i].tlb_ent != -1) {
  885. __asm__ __volatile__("stxa %0, [%1] %2nt"
  886.      "membar #Sync"
  887.      : : "r" (prom_itlb[i].tlb_tag),
  888.      "r" (TLB_TAG_ACCESS),
  889.      "i" (ASI_IMMU));
  890. if (tlb_type == spitfire)
  891. spitfire_put_itlb_data(prom_itlb[i].tlb_ent,
  892.        prom_itlb[i].tlb_data);
  893. else
  894. cheetah_put_litlb_data(prom_itlb[i].tlb_ent,
  895.        prom_itlb[i].tlb_data);
  896. }
  897. }
  898. }
  900. void __flush_dcache_range(unsigned long start, unsigned long end)
  901. {
  902. unsigned long va;
  904. if (tlb_type == spitfire) {
  905. int n = 0;
  907. for (va = start; va < end; va += 32) {
  908. spitfire_put_dcache_tag(va & 0x3fe0, 0x0);
  909. if (++n >= 512)
  910. break;
  911. }
  912. } else {
  913. start = __pa(start);
  914. end = __pa(end);
  915. for (va = start; va < end; va += 32)
  916. __asm__ __volatile__("stxa %%g0, [%0] %1nt"
  917.      "membar #Sync"
  918.      : /* no outputs */
  919.      : "r" (va),
  920.        "i" (ASI_DCACHE_INVALIDATE));
  921. }
  922. }
  924. void __flush_cache_all(void)
  925. {
  926. /* Cheetah should be fine here too. */
  927. if (tlb_type == spitfire) {
  928. unsigned long va;
  930. flushw_all();
  931. for (va =  0; va < (PAGE_SIZE << 1); va += 32)
  932. spitfire_put_icache_tag(va, 0x0);
  933. __asm__ __volatile__("flush %g6");
  934. }
  935. }
  937. /* If not locked, zap it. */
  938. void __flush_tlb_all(void)
  939. {
  940. unsigned long pstate;
  941. int i;
  943. __asm__ __volatile__("flushwnt"
  944.      "rdpr %%pstate, %0nt"
  945.      "wrpr %0, %1, %%pstate"
  946.      : "=r" (pstate)
  947.      : "i" (PSTATE_IE));
  948. if (tlb_type == spitfire) {
  949. for (i = 0; i < 64; i++) {
  950. /* Spitfire Errata #32 workaround */
  951. __asm__ __volatile__("stxa %0, [%1] %2nt"
  952.      "flush %%g6"
  953.      : /* No outputs */
  954.      : "r" (0),
  955.      "r" (PRIMARY_CONTEXT), "i" (ASI_DMMU));
  957. if (!(spitfire_get_dtlb_data(i) & _PAGE_L)) {
  958. __asm__ __volatile__("stxa %%g0, [%0] %1nt"
  959.      "membar #Sync"
  960.      : /* no outputs */
  961.      : "r" (TLB_TAG_ACCESS), "i" (ASI_DMMU));
  962. spitfire_put_dtlb_data(i, 0x0UL);
  963. }
  965. /* Spitfire Errata #32 workaround */
  966. __asm__ __volatile__("stxa %0, [%1] %2nt"
  967.      "flush %%g6"
  968.      : /* No outputs */
  969.      : "r" (0),
  970.      "r" (PRIMARY_CONTEXT), "i" (ASI_DMMU));
  972. if (!(spitfire_get_itlb_data(i) & _PAGE_L)) {
  973. __asm__ __volatile__("stxa %%g0, [%0] %1nt"
  974.      "membar #Sync"
  975.      : /* no outputs */
  976.      : "r" (TLB_TAG_ACCESS), "i" (ASI_IMMU));
  977. spitfire_put_itlb_data(i, 0x0UL);
  978. }
  979. }
  980. } else if (tlb_type == cheetah) {
  981. cheetah_flush_dtlb_all();
  982. cheetah_flush_itlb_all();
  983. }
  984. __asm__ __volatile__("wrpr %0, 0, %%pstate"
  985.      : : "r" (pstate));
  986. }
  988. /* Caller does TLB context flushing on local CPU if necessary.
  989.  * The caller also ensures that CTX_VALID(mm->context) is false.
  990.  *
  991.  * We must be careful about boundary cases so that we never
  992.  * let the user have CTX 0 (nucleus) or we ever use a CTX
  993.  * version of zero (and thus NO_CONTEXT would not be caught
  994.  * by version mis-match tests in mmu_context.h).
  995.  */
  996. void get_new_mmu_context(struct mm_struct *mm)
  997. {
  998. unsigned long ctx, new_ctx;
  1000. spin_lock(&ctx_alloc_lock);
  1001. ctx = CTX_HWBITS(tlb_context_cache + 1);
  1002. new_ctx = find_next_zero_bit(mmu_context_bmap, 1UL << CTX_VERSION_SHIFT, ctx);
  1003. if (new_ctx >= (1UL << CTX_VERSION_SHIFT)) {
  1004. new_ctx = find_next_zero_bit(mmu_context_bmap, ctx, 1);
  1005. if (new_ctx >= ctx) {
  1006. int i;
  1007. new_ctx = (tlb_context_cache & CTX_VERSION_MASK) +
  1008. CTX_FIRST_VERSION;
  1009. if (new_ctx == 1)
  1010. new_ctx = CTX_FIRST_VERSION;
  1012. /* Don't call memset, for 16 entries that's just
  1013.  * plain silly...
  1014.  */
  1015. mmu_context_bmap[0] = 3;
  1016. mmu_context_bmap[1] = 0;
  1017. mmu_context_bmap[2] = 0;
  1018. mmu_context_bmap[3] = 0;
  1019. for (i = 4; i < CTX_BMAP_SLOTS; i += 4) {
  1020. mmu_context_bmap[i + 0] = 0;
  1021. mmu_context_bmap[i + 1] = 0;
  1022. mmu_context_bmap[i + 2] = 0;
  1023. mmu_context_bmap[i + 3] = 0;
  1024. }
  1025. goto out;
  1026. }
  1027. }
  1028. mmu_context_bmap[new_ctx>>6] |= (1UL << (new_ctx & 63));
  1029. new_ctx |= (tlb_context_cache & CTX_VERSION_MASK);
  1030. out:
  1031. tlb_context_cache = new_ctx;
  1032. spin_unlock(&ctx_alloc_lock);
  1034. mm->context = new_ctx;
  1035. }
  1037. #ifndef CONFIG_SMP
  1038. struct pgtable_cache_struct pgt_quicklists;
  1039. #endif
  1041. /* OK, we have to color these pages. The page tables are accessed
  1042.  * by non-Dcache enabled mapping in the VPTE area by the dtlb_backend.S
  1043.  * code, as well as by PAGE_OFFSET range direct-mapped addresses by 
  1044.  * other parts of the kernel. By coloring, we make sure that the tlbmiss 
  1045.  * fast handlers do not get data from old/garbage dcache lines that 
  1046.  * correspond to an old/stale virtual address (user/kernel) that 
  1047.  * previously mapped the pagetable page while accessing vpte range 
  1048.  * addresses. The idea is that if the vpte color and PAGE_OFFSET range 
  1049.  * color is the same, then when the kernel initializes the pagetable 
  1050.  * using the later address range, accesses with the first address
  1051.  * range will see the newly initialized data rather than the garbage.
  1052.  */
  1053. #if (L1DCACHE_SIZE > PAGE_SIZE) /* is there D$ aliasing problem */
  1054. #define DC_ALIAS_SHIFT 1
  1055. #else
  1056. #define DC_ALIAS_SHIFT 0
  1057. #endif
  1058. pte_t *pte_alloc_one(struct mm_struct *mm, unsigned long address)
  1059. {
  1060. struct page *page = alloc_pages(GFP_KERNEL, DC_ALIAS_SHIFT);
  1061. unsigned long color = VPTE_COLOR(address);
  1063. if (page) {
  1064. unsigned long *to_free;
  1065. unsigned long paddr;
  1066. pte_t *pte;
  1068. #if (L1DCACHE_SIZE > PAGE_SIZE) /* is there D$ aliasing problem */
  1069. set_page_count((page + 1), 1);
  1070. #endif
  1071. paddr = (unsigned long) page_address(page);
  1072. memset((char *)paddr, 0, (PAGE_SIZE << DC_ALIAS_SHIFT));
  1074. if (!color) {
  1075. pte = (pte_t *) paddr;
  1076. to_free = (unsigned long *) (paddr + PAGE_SIZE);
  1077. } else {
  1078. pte = (pte_t *) (paddr + PAGE_SIZE);
  1079. to_free = (unsigned long *) paddr;
  1080. }
  1082. #if (L1DCACHE_SIZE > PAGE_SIZE) /* is there D$ aliasing problem */
  1083. /* Now free the other one up, adjust cache size. */
  1084. *to_free = (unsigned long) pte_quicklist[color ^ 0x1];
  1085. pte_quicklist[color ^ 0x1] = to_free;
  1086. pgtable_cache_size++;
  1087. #endif
  1089. return pte;
  1090. }
  1091. return NULL;
  1092. }
  1094. void sparc_ultra_dump_itlb(void)
  1095. {
  1096.         int slot;
  1098. if (tlb_type == spitfire) {
  1099. printk ("Contents of itlb: ");
  1100. for (slot = 0; slot < 14; slot++) printk ("    ");
  1101. printk ("%2x:%016lx,%016lxn",
  1102. 0,
  1103. spitfire_get_itlb_tag(0), spitfire_get_itlb_data(0));
  1104. for (slot = 1; slot < 64; slot+=3) {
  1105. printk ("%2x:%016lx,%016lx %2x:%016lx,%016lx %2x:%016lx,%016lxn", 
  1106. slot,
  1107. spitfire_get_itlb_tag(slot), spitfire_get_itlb_data(slot),
  1108. slot+1,
  1109. spitfire_get_itlb_tag(slot+1), spitfire_get_itlb_data(slot+1),
  1110. slot+2,
  1111. spitfire_get_itlb_tag(slot+2), spitfire_get_itlb_data(slot+2));
  1112. }
  1113. } else if (tlb_type == cheetah) {
  1114. printk ("Contents of itlb0:n");
  1115. for (slot = 0; slot < 16; slot+=2) {
  1116. printk ("%2x:%016lx,%016lx %2x:%016lx,%016lxn",
  1117. slot,
  1118. cheetah_get_litlb_tag(slot), cheetah_get_litlb_data(slot),
  1119. slot+1,
  1120. cheetah_get_litlb_tag(slot+1), cheetah_get_litlb_data(slot+1));
  1121. }
  1122. printk ("Contents of itlb2:n");
  1123. for (slot = 0; slot < 128; slot+=2) {
  1124. printk ("%2x:%016lx,%016lx %2x:%016lx,%016lxn",
  1125. slot,
  1126. cheetah_get_itlb_tag(slot), cheetah_get_itlb_data(slot),
  1127. slot+1,
  1128. cheetah_get_itlb_tag(slot+1), cheetah_get_itlb_data(slot+1));
  1129. }
  1130. }
  1131. }
  1133. void sparc_ultra_dump_dtlb(void)
  1134. {
  1135.         int slot;
  1137. if (tlb_type == spitfire) {
  1138. printk ("Contents of dtlb: ");
  1139. for (slot = 0; slot < 14; slot++) printk ("    ");
  1140. printk ("%2x:%016lx,%016lxn", 0,
  1141. spitfire_get_dtlb_tag(0), spitfire_get_dtlb_data(0));
  1142. for (slot = 1; slot < 64; slot+=3) {
  1143. printk ("%2x:%016lx,%016lx %2x:%016lx,%016lx %2x:%016lx,%016lxn", 
  1144. slot,
  1145. spitfire_get_dtlb_tag(slot), spitfire_get_dtlb_data(slot),
  1146. slot+1,
  1147. spitfire_get_dtlb_tag(slot+1), spitfire_get_dtlb_data(slot+1),
  1148. slot+2,
  1149. spitfire_get_dtlb_tag(slot+2), spitfire_get_dtlb_data(slot+2));
  1150. }
  1151. } else if (tlb_type == cheetah) {
  1152. printk ("Contents of dtlb0:n");
  1153. for (slot = 0; slot < 16; slot+=2) {
  1154. printk ("%2x:%016lx,%016lx %2x:%016lx,%016lxn",
  1155. slot,
  1156. cheetah_get_ldtlb_tag(slot), cheetah_get_ldtlb_data(slot),
  1157. slot+1,
  1158. cheetah_get_ldtlb_tag(slot+1), cheetah_get_ldtlb_data(slot+1));
  1159. }
  1160. printk ("Contents of dtlb2:n");
  1161. for (slot = 0; slot < 512; slot+=2) {
  1162. printk ("%2x:%016lx,%016lx %2x:%016lx,%016lxn",
  1163. slot,
  1164. cheetah_get_dtlb_tag(slot), cheetah_get_dtlb_data(slot),
  1165. slot+1,
  1166. cheetah_get_dtlb_tag(slot+1), cheetah_get_dtlb_data(slot+1));
  1167. }
  1168. }
  1169. }
  1171. extern unsigned long cmdline_memory_size;
  1173. unsigned long __init bootmem_init(unsigned long *pages_avail)
  1174. {
  1175. unsigned long bootmap_size, start_pfn, end_pfn;
  1176. unsigned long end_of_phys_memory = 0UL;
  1177. unsigned long bootmap_pfn, bytes_avail, size;
  1178. int i;
  1180. bytes_avail = 0UL;
  1181. for (i = 0; sp_banks[i].num_bytes != 0; i++) {
  1182. end_of_phys_memory = sp_banks[i].base_addr +
  1183. sp_banks[i].num_bytes;
  1184. bytes_avail += sp_banks[i].num_bytes;
  1185. if (cmdline_memory_size) {
  1186. if (bytes_avail > cmdline_memory_size) {
  1187. unsigned long slack = bytes_avail - cmdline_memory_size;
  1189. bytes_avail -= slack;
  1190. end_of_phys_memory -= slack;
  1192. sp_banks[i].num_bytes -= slack;
  1193. if (sp_banks[i].num_bytes == 0) {
  1194. sp_banks[i].base_addr = 0xdeadbeef;
  1195. } else {
  1196. sp_banks[i+1].num_bytes = 0;
  1197. sp_banks[i+1].base_addr = 0xdeadbeef;
  1198. }
  1199. break;
  1200. }
  1201. }
  1202. }
  1204. *pages_avail = bytes_avail >> PAGE_SHIFT;
  1206. /* Start with page aligned address of last symbol in kernel
  1207.  * image.  The kernel is hard mapped below PAGE_OFFSET in a
  1208.  * 4MB locked TLB translation.
  1209.  */
  1210. start_pfn  = PAGE_ALIGN((unsigned long) &_end) -
  1211. ((unsigned long) KERNBASE);
  1213. /* Adjust up to the physical address where the kernel begins. */
  1214. start_pfn += phys_base;
  1216. /* Now shift down to get the real physical page frame number. */
  1217. start_pfn >>= PAGE_SHIFT;
  1219. bootmap_pfn = start_pfn;
  1221. end_pfn = end_of_phys_memory >> PAGE_SHIFT;
  1223. #ifdef CONFIG_BLK_DEV_INITRD
  1224. /* Now have to check initial ramdisk, so that bootmap does not overwrite it */
  1225. if (sparc_ramdisk_image) {
  1226. if (sparc_ramdisk_image >= (unsigned long)&_end - 2 * PAGE_SIZE)
  1227. sparc_ramdisk_image -= KERNBASE;
  1228. initrd_start = sparc_ramdisk_image + phys_base;
  1229. initrd_end = initrd_start + sparc_ramdisk_size;
  1230. if (initrd_end > end_of_phys_memory) {
  1231. printk(KERN_CRIT "initrd extends beyond end of memory "
  1232.                    "(0x%016lx > 0x%016lx)ndisabling initrdn",
  1233.        initrd_end, end_of_phys_memory);
  1234. initrd_start = 0;
  1235. }
  1236. if (initrd_start) {
  1237. if (initrd_start >= (start_pfn << PAGE_SHIFT) &&
  1238.     initrd_start < (start_pfn << PAGE_SHIFT) + 2 * PAGE_SIZE)
  1239. bootmap_pfn = PAGE_ALIGN (initrd_end) >> PAGE_SHIFT;
  1240. }
  1241. }
  1242. #endif
  1243. /* Initialize the boot-time allocator. */
  1244. bootmap_size = init_bootmem_node(NODE_DATA(0), bootmap_pfn, phys_base>>PAGE_SHIFT, end_pfn);
  1246. /* Now register the available physical memory with the
  1247.  * allocator.
  1248.  */
  1249. for (i = 0; sp_banks[i].num_bytes != 0; i++)
  1250. free_bootmem(sp_banks[i].base_addr,
  1251.      sp_banks[i].num_bytes);
  1253. #ifdef CONFIG_BLK_DEV_INITRD
  1254. if (initrd_start) {
  1255. size = initrd_end - initrd_start;
  1257. /* Resert the initrd image area. */
  1258. reserve_bootmem(initrd_start, size);
  1259. *pages_avail -= PAGE_ALIGN(size) >> PAGE_SHIFT;
  1261. initrd_start += PAGE_OFFSET;
  1262. initrd_end += PAGE_OFFSET;
  1263. }
  1264. #endif
  1265. /* Reserve the kernel text/data/bss. */
  1266. size = (start_pfn << PAGE_SHIFT) - phys_base;
  1267. reserve_bootmem(phys_base, size);
  1268. *pages_avail -= PAGE_ALIGN(size) >> PAGE_SHIFT;
  1270. /* Reserve the bootmem map.   We do not account for it
  1271.  * in pages_avail because we will release that memory
  1272.  * in free_all_bootmem.
  1273.  */
  1274. size = bootmap_size;
  1275. reserve_bootmem((bootmap_pfn << PAGE_SHIFT), size);
  1276. *pages_avail -= PAGE_ALIGN(size) >> PAGE_SHIFT;
  1278. return end_pfn;
  1279. }
  1281. /* paging_init() sets up the page tables */
  1283. extern void sun_serial_setup(void);
  1284. extern void cheetah_ecache_flush_init(void);
  1286. static unsigned long last_valid_pfn;
  1288. void __init paging_init(void)
  1289. {
  1290. extern pmd_t swapper_pmd_dir[1024];
  1291. extern unsigned int sparc64_vpte_patchme1[1];
  1292. extern unsigned int sparc64_vpte_patchme2[1];
  1293. unsigned long alias_base = phys_base + PAGE_OFFSET;
  1294. unsigned long second_alias_page = 0;
  1295. unsigned long pt, flags, end_pfn, pages_avail;
  1296. unsigned long shift = alias_base - ((unsigned long)KERNBASE);
  1297. unsigned long real_end;
  1299. set_bit(0, mmu_context_bmap);
  1301. real_end = (unsigned long)&_end;
  1302. if ((real_end > ((unsigned long)KERNBASE + 0x400000)))
  1303. bigkernel = 1;
  1304. #ifdef CONFIG_BLK_DEV_INITRD
  1305. if (sparc_ramdisk_image)
  1306. real_end = (PAGE_ALIGN(real_end) + PAGE_ALIGN(sparc_ramdisk_size));
  1307. #endif
  1309. /* We assume physical memory starts at some 4mb multiple,
  1310.  * if this were not true we wouldn't boot up to this point
  1311.  * anyways.
  1312.  */
  1313. pt  = phys_base | _PAGE_VALID | _PAGE_SZ4MB;
  1314. pt |= _PAGE_CP | _PAGE_CV | _PAGE_P | _PAGE_L | _PAGE_W;
  1315. __save_and_cli(flags);
  1316. if (tlb_type == spitfire) {
  1317. __asm__ __volatile__(
  1318. " stxa %1, [%0] %3n"
  1319. " stxa %2, [%5] %4n"
  1320. " membar #Syncn"
  1321. " flush %%g6n"
  1322. " nopn"
  1323. " nopn"
  1324. " nopn"
  1325. : /* No outputs */
  1326. : "r" (TLB_TAG_ACCESS), "r" (alias_base), "r" (pt),
  1327.   "i" (ASI_DMMU), "i" (ASI_DTLB_DATA_ACCESS), "r" (61 << 3)
  1328. : "memory");
  1329. if (real_end >= KERNBASE + 0x340000) {
  1330. second_alias_page = alias_base + 0x400000;
  1331. __asm__ __volatile__(
  1332. " stxa %1, [%0] %3n"
  1333. " stxa %2, [%5] %4n"
  1334. " membar #Syncn"
  1335. " flush %%g6n"
  1336. " nopn"
  1337. " nopn"
  1338. " nopn"
  1339. : /* No outputs */
  1340. : "r" (TLB_TAG_ACCESS), "r" (second_alias_page), "r" (pt + 0x400000),
  1341.   "i" (ASI_DMMU), "i" (ASI_DTLB_DATA_ACCESS), "r" (60 << 3)
  1342. : "memory");
  1343. }
  1344. } else if (tlb_type == cheetah) {
  1345. __asm__ __volatile__(
  1346. " stxa %1, [%0] %3n"
  1347. " stxa %2, [%5] %4n"
  1348. " membar #Syncn"
  1349. " flush %%g6n"
  1350. " nopn"
  1351. " nopn"
  1352. " nopn"
  1353. : /* No outputs */
  1354. : "r" (TLB_TAG_ACCESS), "r" (alias_base), "r" (pt),
  1355.   "i" (ASI_DMMU), "i" (ASI_DTLB_DATA_ACCESS), "r" ((0<<16) | (13<<3))
  1356. : "memory");
  1357. if (real_end >= KERNBASE + 0x340000) {
  1358. second_alias_page = alias_base + 0x400000;
  1359. __asm__ __volatile__(
  1360. " stxa %1, [%0] %3n"
  1361. " stxa %2, [%5] %4n"
  1362. " membar #Syncn"
  1363. " flush %%g6n"
  1364. " nopn"
  1365. " nopn"
  1366. " nopn"
  1367. : /* No outputs */
  1368. : "r" (TLB_TAG_ACCESS), "r" (second_alias_page), "r" (pt + 0x400000),
  1369.   "i" (ASI_DMMU), "i" (ASI_DTLB_DATA_ACCESS), "r" ((0<<16) | (12<<3))
  1370. : "memory");
  1371. }
  1372. }
  1373. __restore_flags(flags);
  1375. /* Now set kernel pgd to upper alias so physical page computations
  1376.  * work.
  1377.  */
  1378. init_mm.pgd += ((shift) / (sizeof(pgd_t)));
  1380. memset(swapper_pmd_dir, 0, sizeof(swapper_pmd_dir));
  1382. /* Now can init the kernel/bad page tables. */
  1383. pgd_set(&swapper_pg_dir[0], swapper_pmd_dir + (shift / sizeof(pgd_t)));
  1385. sparc64_vpte_patchme1[0] |= (pgd_val(init_mm.pgd[0]) >> 10);
  1386. sparc64_vpte_patchme2[0] |= (pgd_val(init_mm.pgd[0]) & 0x3ff);
  1387. flushi((long)&sparc64_vpte_patchme1[0]);
  1389. /* Setup bootmem... */
  1390. pages_avail = 0;
  1391. last_valid_pfn = end_pfn = bootmem_init(&pages_avail);
  1393. #ifdef CONFIG_SUN_SERIAL
  1394. /* This does not logically belong here, but we need to
  1395.  * call it at the moment we are able to use the bootmem
  1396.  * allocator.
  1397.  */
  1398. sun_serial_setup();
  1399. #endif
  1401. /* Inherit non-locked OBP mappings. */
  1402. inherit_prom_mappings();
  1404. /* Ok, we can use our TLB miss and window trap handlers safely.
  1405.  * We need to do a quick peek here to see if we are on StarFire
  1406.  * or not, so setup_tba can setup the IRQ globals correctly (it
  1407.  * needs to get the hard smp processor id correctly).
  1408.  */
  1409. {
  1410. extern void setup_tba(int);
  1411. setup_tba(this_is_starfire);
  1412. }
  1414. inherit_locked_prom_mappings(1);
  1416. /* We only created DTLB mapping of this stuff. */
  1417. spitfire_flush_dtlb_nucleus_page(alias_base);
  1418. if (second_alias_page)
  1419. spitfire_flush_dtlb_nucleus_page(second_alias_page);
  1421. __flush_tlb_all();
  1423. {
  1424. unsigned long zones_size[MAX_NR_ZONES];
  1425. unsigned long zholes_size[MAX_NR_ZONES];
  1426. unsigned long npages;
  1427. int znum;
  1429. for (znum = 0; znum < MAX_NR_ZONES; znum++)
  1430. zones_size[znum] = zholes_size[znum] = 0;
  1432. npages = end_pfn - (phys_base >> PAGE_SHIFT);
  1433. zones_size[ZONE_DMA] = npages;
  1434. zholes_size[ZONE_DMA] = npages - pages_avail;
  1436. free_area_init_node(0, NULL, NULL, zones_size,
  1437.     phys_base, zholes_size);
  1438. }
  1440. device_scan();
  1441. }
  1443. /* Ok, it seems that the prom can allocate some more memory chunks
  1444.  * as a side effect of some prom calls we perform during the
  1445.  * boot sequence.  My most likely theory is that it is from the
  1446.  * prom_set_traptable() call, and OBP is allocating a scratchpad
  1447.  * for saving client program register state etc.
  1448.  */
  1449. void __init sort_memlist(struct linux_mlist_p1275 *thislist)
  1450. {
  1451. int swapi = 0;
  1452. int i, mitr;
  1453. unsigned long tmpaddr, tmpsize;
  1454. unsigned long lowest;
  1456. for (i = 0; thislist[i].theres_more != 0; i++) {
  1457. lowest = thislist[i].start_adr;
  1458. for (mitr = i+1; thislist[mitr-1].theres_more != 0; mitr++)
  1459. if (thislist[mitr].start_adr < lowest) {
  1460. lowest = thislist[mitr].start_adr;
  1461. swapi = mitr;
  1462. }
  1463. if (lowest == thislist[i].start_adr)
  1464. continue;
  1465. tmpaddr = thislist[swapi].start_adr;
  1466. tmpsize = thislist[swapi].num_bytes;
  1467. for (mitr = swapi; mitr > i; mitr--) {
  1468. thislist[mitr].start_adr = thislist[mitr-1].start_adr;
  1469. thislist[mitr].num_bytes = thislist[mitr-1].num_bytes;
  1470. }
  1471. thislist[i].start_adr = tmpaddr;
  1472. thislist[i].num_bytes = tmpsize;
  1473. }
  1474. }
  1476. void __init rescan_sp_banks(void)
  1477. {
  1478. struct linux_prom64_registers memlist[64];
  1479. struct linux_mlist_p1275 avail[64], *mlist;
  1480. unsigned long bytes, base_paddr;
  1481. int num_regs, node = prom_finddevice("/memory");
  1482. int i;
  1484. num_regs = prom_getproperty(node, "available",
  1485.     (char *) memlist, sizeof(memlist));
  1486. num_regs = (num_regs / sizeof(struct linux_prom64_registers));
  1487. for (i = 0; i < num_regs; i++) {
  1488. avail[i].start_adr = memlist[i].phys_addr;
  1489. avail[i].num_bytes = memlist[i].reg_size;
  1490. avail[i].theres_more = &avail[i + 1];
  1491. }
  1492. avail[i - 1].theres_more = NULL;
  1493. sort_memlist(avail);
  1495. mlist = &avail[0];
  1496. i = 0;
  1497. bytes = mlist->num_bytes;
  1498. base_paddr = mlist->start_adr;
  1499.   
  1500. sp_banks[0].base_addr = base_paddr;
  1501. sp_banks[0].num_bytes = bytes;
  1503. while (mlist->theres_more != NULL){
  1504. i++;
  1505. mlist = mlist->theres_more;
  1506. bytes = mlist->num_bytes;
  1507. if (i >= SPARC_PHYS_BANKS-1) {
  1508. printk ("The machine has more banks than "
  1509. "this kernel can supportn"
  1510. "Increase the SPARC_PHYS_BANKS "
  1511. "setting (currently %d)n",
  1512. SPARC_PHYS_BANKS);
  1513. i = SPARC_PHYS_BANKS-1;
  1514. break;
  1515. }
  1516.     
  1517. sp_banks[i].base_addr = mlist->start_adr;
  1518. sp_banks[i].num_bytes = mlist->num_bytes;
  1519. }
  1521. i++;
  1522. sp_banks[i].base_addr = 0xdeadbeefbeefdeadUL;
  1523. sp_banks[i].num_bytes = 0;
  1525. for (i = 0; sp_banks[i].num_bytes != 0; i++)
  1526. sp_banks[i].num_bytes &= PAGE_MASK;
  1527. }
  1529. static void __init taint_real_pages(void)
  1530. {
  1531. struct sparc_phys_banks saved_sp_banks[SPARC_PHYS_BANKS];
  1532. int i;
  1534. for (i = 0; i < SPARC_PHYS_BANKS; i++) {
  1535. saved_sp_banks[i].base_addr =
  1536. sp_banks[i].base_addr;
  1537. saved_sp_banks[i].num_bytes =
  1538. sp_banks[i].num_bytes;
  1539. }
  1541. rescan_sp_banks();
  1543. /* Find changes discovered in the sp_bank rescan and
  1544.  * reserve the lost portions in the bootmem maps.
  1545.  */
  1546. for (i = 0; saved_sp_banks[i].num_bytes; i++) {
  1547. unsigned long old_start, old_end;
  1549. old_start = saved_sp_banks[i].base_addr;
  1550. old_end = old_start +
  1551. saved_sp_banks[i].num_bytes;
  1552. while (old_start < old_end) {
  1553. int n;
  1555. for (n = 0; sp_banks[n].num_bytes; n++) {
  1556. unsigned long new_start, new_end;
  1558. new_start = sp_banks[n].base_addr;
  1559. new_end = new_start + sp_banks[n].num_bytes;
  1561. if (new_start <= old_start &&
  1562.     new_end >= (old_start + PAGE_SIZE)) {
  1563. set_bit (old_start >> 22,
  1564.  sparc64_valid_addr_bitmap);
  1565. goto do_next_page;
  1566. }
  1567. }
  1568. reserve_bootmem(old_start, PAGE_SIZE);
  1570. do_next_page:
  1571. old_start += PAGE_SIZE;
  1572. }
  1573. }
  1574. }
  1576. void __init mem_init(void)
  1577. {
  1578. unsigned long codepages, datapages, initpages;
  1579. unsigned long addr, last;
  1580. int i;
  1582. i = last_valid_pfn >> ((22 - PAGE_SHIFT) + 6);
  1583. i += 1;
  1584. sparc64_valid_addr_bitmap = (unsigned long *)
  1585. __alloc_bootmem(i << 3, SMP_CACHE_BYTES, 0UL);
  1586. if (sparc64_valid_addr_bitmap == NULL) {
  1587. prom_printf("mem_init: Cannot alloc valid_addr_bitmap.n");
  1588. prom_halt();
  1589. }
  1590. memset(sparc64_valid_addr_bitmap, 0, i << 3);
  1592. addr = PAGE_OFFSET + phys_base;
  1593. last = PAGE_ALIGN((unsigned long)&_end) -
  1594. ((unsigned long) KERNBASE);
  1595. last += PAGE_OFFSET + phys_base;
  1596. while (addr < last) {
  1597. set_bit(__pa(addr) >> 22, sparc64_valid_addr_bitmap);
  1598. addr += PAGE_SIZE;
  1599. }
  1601. taint_real_pages();
  1603. max_mapnr = last_valid_pfn - (phys_base >> PAGE_SHIFT);
  1604. high_memory = __va(last_valid_pfn << PAGE_SHIFT);
  1606. num_physpages = free_all_bootmem() - 1;
  1608. /*
  1609.  * Set up the zero page, mark it reserved, so that page count
  1610.  * is not manipulated when freeing the page from user ptes.
  1611.  */
  1612. mem_map_zero = _alloc_pages(GFP_KERNEL, 0);
  1613. if (mem_map_zero == NULL) {
  1614. prom_printf("paging_init: Cannot alloc zero page.n");
  1615. prom_halt();
  1616. }
  1617. SetPageReserved(mem_map_zero);
  1618. clear_page(page_address(mem_map_zero));
  1620. codepages = (((unsigned long) &etext) - ((unsigned long)&_start));
  1621. codepages = PAGE_ALIGN(codepages) >> PAGE_SHIFT;
  1622. datapages = (((unsigned long) &edata) - ((unsigned long)&etext));
  1623. datapages = PAGE_ALIGN(datapages) >> PAGE_SHIFT;
  1624. initpages = (((unsigned long) &__init_end) - ((unsigned long) &__init_begin));
  1625. initpages = PAGE_ALIGN(initpages) >> PAGE_SHIFT;
  1627. #ifndef CONFIG_SMP
  1628. {
  1629. /* Put empty_pg_dir on pgd_quicklist */
  1630. extern pgd_t empty_pg_dir[1024];
  1631. unsigned long addr = (unsigned long)empty_pg_dir;
  1632. unsigned long alias_base = phys_base + PAGE_OFFSET -
  1633. (long)(KERNBASE);
  1635. memset(empty_pg_dir, 0, sizeof(empty_pg_dir));
  1636. addr += alias_base;
  1637. free_pgd_fast((pgd_t *)addr);
  1638. num_physpages++;
  1639. }
  1640. #endif
  1642. printk("Memory: %uk available (%ldk kernel code, %ldk data, %ldk init) [%016lx,%016lx]n",
  1643.        nr_free_pages() << (PAGE_SHIFT-10),
  1644.        codepages << (PAGE_SHIFT-10),
  1645.        datapages << (PAGE_SHIFT-10), 
  1646.        initpages << (PAGE_SHIFT-10), 
  1647.        PAGE_OFFSET, (last_valid_pfn << PAGE_SHIFT));
  1649. if (tlb_type == cheetah)
  1650. cheetah_ecache_flush_init();
  1651. }
  1653. void free_initmem (void)
  1654. {
  1655. unsigned long addr, initend;
  1657. /*
  1658.  * The init section is aligned to 8k in vmlinux.lds. Page align for >8k pagesizes.
  1659.  */
  1660. addr = PAGE_ALIGN((unsigned long)(&__init_begin));
  1661. initend = (unsigned long)(&__init_end) & PAGE_MASK;
  1662. for (; addr < initend; addr += PAGE_SIZE) {
  1663. unsigned long page;
  1664. struct page *p;
  1666. page = (addr +
  1667. ((unsigned long) __va(phys_base)) -
  1668. ((unsigned long) KERNBASE));
  1669. p = virt_to_page(page);
  1671. ClearPageReserved(p);
  1672. set_page_count(p, 1);
  1673. __free_page(p);
  1674. num_physpages++;
  1675. }
  1676. }
  1678. #ifdef CONFIG_BLK_DEV_INITRD
  1679. void free_initrd_mem(unsigned long start, unsigned long end)
  1680. {
  1681. if (start < end)
  1682. printk ("Freeing initrd memory: %ldk freedn", (end - start) >> 10);
  1683. for (; start < end; start += PAGE_SIZE) {
  1684. struct page *p = virt_to_page(start);
  1686. ClearPageReserved(p);
  1687. set_page_count(p, 1);
  1688. __free_page(p);
  1689. num_physpages++;
  1690. }
  1691. }
  1692. #endif
  1694. void si_meminfo(struct sysinfo *val)
  1695. {
  1696. val->totalram = num_physpages;
  1697. val->sharedram = 0;
  1698. val->freeram = nr_free_pages();
  1699. val->bufferram = atomic_read(&buffermem_pages);
  1701. /* These are always zero on Sparc64. */
  1702. val->totalhigh = 0;
  1703. val->freehigh = 0;
  1705. val->mem_unit = PAGE_SIZE;
  1706. }