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

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

嵌入式Linux

开发平台：

Unix_Linux

r5432.c：源码内容
  1. /*
  2.  * This file is subject to the terms and conditions of the GNU General Public
  3.  * License.  See the file "COPYING" in the main directory of this archive
  4.  * for more details.
  5.  *
  6.  * r5432.c: NEC Vr5432 processor.  We cannot use r4xx0.c because of
  7.  *      its unique way-selection method for indexed operations.
  8.  *
  9.  * Copyright (C) 1996 David S. Miller (dm@engr.sgi.com)
  10.  * Copyright (C) 1997, 1998, 1999, 2000 Ralf Baechle (ralf@gnu.org)
  11.  * Copyright (C) 2000 Jun Sun (jsun@mvista.com)
  12.  *
  13.  */
  15. /*
  16.  * [jsun]
  17.  * In a sense, this is really silly.  We cannot re-use r4xx0.c because
  18.  * the lowest-level indexed cache operation does not take way-selection
  19.  * into account.  So all what I am doing here is to copy all the funcs
  20.  * and macros (in r4kcache.h) relavent to R5432 to this file, and then
  21.  * modify a few indexed cache operations.  *sigh*
  22.  */
  24. #include <linux/init.h>
  25. #include <linux/kernel.h>
  26. #include <linux/sched.h>
  27. #include <linux/mm.h>
  29. #include <asm/bcache.h>
  30. #include <asm/io.h>
  31. #include <asm/page.h>
  32. #include <asm/pgtable.h>
  33. #include <asm/system.h>
  34. #include <asm/bootinfo.h>
  35. #include <asm/mmu_context.h>
  37. /* CP0 hazard avoidance. */
  38. #define BARRIER __asm__ __volatile__(".set noreordernt" 
  39.      "nop; nop; nop; nop; nop; nop;nt" 
  40.      ".set reordernt")
  42. #include <asm/asm.h>
  43. #include <asm/cacheops.h>
  45. #undef DEBUG_CACHE
  47. /* Primary cache parameters. */
  48. static int icache_size, dcache_size; /* Size in bytes */
  49. static int ic_lsize, dc_lsize;       /* LineSize in bytes */
  52. /* -------------------------------------------------------------------- */
  53. /* #include <asm/r4kcache.h> */
  55. extern inline void flush_icache_line_indexed(unsigned long addr)
  56. {
  57. __asm__ __volatile__(
  58. ".set noreordernt"
  59. ".set mips3nt"
  60. "cache %1, (%0)nt"
  61. "cache %1, 1(%0)nt"
  62. ".set mips0nt"
  63. ".set reorder"
  64. :
  65. : "r" (addr),
  66.   "i" (Index_Invalidate_I));
  67. }
  69. extern inline void flush_dcache_line_indexed(unsigned long addr)
  70. {
  71. __asm__ __volatile__(
  72. ".set noreordernt"
  73. ".set mips3nt"
  74. "cache %1, (%0)nt"
  75. "cache %1, 1(%0)nt"
  76. ".set mips0nt"
  77. ".set reorder"
  78. :
  79. : "r" (addr),
  80.   "i" (Index_Writeback_Inv_D));
  81. }
  83. extern inline void flush_icache_line(unsigned long addr)
  84. {
  85. __asm__ __volatile__(
  86. ".set noreordernt"
  87. ".set mips3nt"
  88. "cache %1, (%0)nt"
  89. ".set mips0nt"
  90. ".set reorder"
  91. :
  92. : "r" (addr),
  93.   "i" (Hit_Invalidate_I));
  94. }
  96. extern inline void flush_dcache_line(unsigned long addr)
  97. {
  98. __asm__ __volatile__(
  99. ".set noreordernt"
  100. ".set mips3nt"
  101. "cache %1, (%0)nt"
  102. ".set mips0nt"
  103. ".set reorder"
  104. :
  105. : "r" (addr),
  106.   "i" (Hit_Writeback_Inv_D));
  107. }
  109. extern inline void invalidate_dcache_line(unsigned long addr)
  110. {
  111. __asm__ __volatile__(
  112. ".set noreordernt"
  113. ".set mips3nt"
  114. "cache %1, (%0)nt"
  115. ".set mips0nt"
  116. ".set reorder"
  117. :
  118. : "r" (addr),
  119.   "i" (Hit_Invalidate_D));
  120. }
  123. /*
  124.  * The next two are for badland addresses like signal trampolines.
  125.  */
  126. extern inline void protected_flush_icache_line(unsigned long addr)
  127. {
  128. __asm__ __volatile__(
  129. ".set noreordernt"
  130. ".set mips3n"
  131. "1:tcache %1,(%0)n"
  132. "2:t.set mips0nt"
  133. ".set reordernt"
  134. ".sectiont__ex_table,"a"nt"
  135. STR(PTR)"t1b,2bnt"
  136. ".previous"
  137. :
  138. : "r" (addr),
  139.   "i" (Hit_Invalidate_I));
  140. }
  142. extern inline void protected_writeback_dcache_line(unsigned long addr)
  143. {
  144. __asm__ __volatile__(
  145. ".set noreordernt"
  146. ".set mips3n"
  147. "1:tcache %1,(%0)n"
  148. "2:t.set mips0nt"
  149. ".set reordernt"
  150. ".sectiont__ex_table,"a"nt"
  151. STR(PTR)"t1b,2bnt"
  152. ".previous"
  153. :
  154. : "r" (addr),
  155.   "i" (Hit_Writeback_D));
  156. }
  159. #define cache32_unroll32(base,op)
  160. __asm__ __volatile__("
  161. .set noreorder;
  162. .set mips3;
  163. cache %1, 0x000(%0); cache %1, 0x020(%0);
  164. cache %1, 0x040(%0); cache %1, 0x060(%0);
  165. cache %1, 0x080(%0); cache %1, 0x0a0(%0);
  166. cache %1, 0x0c0(%0); cache %1, 0x0e0(%0);
  167. cache %1, 0x100(%0); cache %1, 0x120(%0);
  168. cache %1, 0x140(%0); cache %1, 0x160(%0);
  169. cache %1, 0x180(%0); cache %1, 0x1a0(%0);
  170. cache %1, 0x1c0(%0); cache %1, 0x1e0(%0);
  171. cache %1, 0x200(%0); cache %1, 0x220(%0);
  172. cache %1, 0x240(%0); cache %1, 0x260(%0);
  173. cache %1, 0x280(%0); cache %1, 0x2a0(%0);
  174. cache %1, 0x2c0(%0); cache %1, 0x2e0(%0);
  175. cache %1, 0x300(%0); cache %1, 0x320(%0);
  176. cache %1, 0x340(%0); cache %1, 0x360(%0);
  177. cache %1, 0x380(%0); cache %1, 0x3a0(%0);
  178. cache %1, 0x3c0(%0); cache %1, 0x3e0(%0);
  179. .set mips0;
  180. .set reorder"
  181. :
  182. : "r" (base),
  183.   "i" (op));
  185. extern inline void blast_dcache32(void)
  186. {
  187. unsigned long start = KSEG0;
  188. unsigned long end = (start + dcache_size/2);
  190. while(start < end) {
  191. cache32_unroll32(start,Index_Writeback_Inv_D);
  192. cache32_unroll32(start+1,Index_Writeback_Inv_D);
  193. start += 0x400;
  194. }
  195. }
  197. extern inline void blast_dcache32_page(unsigned long page)
  198. {
  199. unsigned long start = page;
  200. unsigned long end = (start + PAGE_SIZE);
  202. while(start < end) {
  203. cache32_unroll32(start,Hit_Writeback_Inv_D);
  204. start += 0x400;
  205. }
  206. }
  208. extern inline void blast_dcache32_page_indexed(unsigned long page)
  209. {
  210. unsigned long start = page;
  211. unsigned long end = (start + PAGE_SIZE);
  213. while(start < end) {
  214. cache32_unroll32(start,Index_Writeback_Inv_D);
  215. cache32_unroll32(start+1,Index_Writeback_Inv_D);
  216. start += 0x400;
  217. }
  218. }
  220. extern inline void blast_icache32(void)
  221. {
  222. unsigned long start = KSEG0;
  223. unsigned long end = (start + icache_size/2);
  225. while(start < end) {
  226. cache32_unroll32(start,Index_Invalidate_I);
  227. cache32_unroll32(start+1,Index_Invalidate_I);
  228. start += 0x400;
  229. }
  230. }
  232. extern inline void blast_icache32_page(unsigned long page)
  233. {
  234. unsigned long start = page;
  235. unsigned long end = (start + PAGE_SIZE);
  237. while(start < end) {
  238. cache32_unroll32(start,Hit_Invalidate_I);
  239. start += 0x400;
  240. }
  241. }
  243. extern inline void blast_icache32_page_indexed(unsigned long page)
  244. {
  245. unsigned long start = page;
  246. unsigned long end = (start + PAGE_SIZE);
  248. while(start < end) {
  249. cache32_unroll32(start,Index_Invalidate_I);
  250. cache32_unroll32(start+1,Index_Invalidate_I);
  251. start += 0x400;
  252. }
  253. }
  255. /* -------------------------------------------------------------------- */
  257. static void r5432_clear_page_d32(void * page)
  258. {
  259. __asm__ __volatile__(
  260. ".settnoreordernt"
  261. ".settnoatnt"
  262. ".settmips3nt"
  263. "daddiut$1,%0,%2n"
  264. "1:tcachet%3,(%0)nt"
  265. "sdt$0,(%0)nt"
  266. "sdt$0,8(%0)nt"
  267. "sdt$0,16(%0)nt"
  268. "sdt$0,24(%0)nt"
  269. "daddiut%0,64nt"
  270. "cachet%3,-32(%0)nt"
  271. "sdt$0,-32(%0)nt"
  272. "sdt$0,-24(%0)nt"
  273. "sdt$0,-16(%0)nt"
  274. "bnet$1,%0,1bnt"
  275. "sdt$0,-8(%0)nt"
  276. ".settmips0nt"
  277. ".settatnt"
  278. ".settreorder"
  279. :"=r" (page)
  280. :"0" (page),
  281.  "I" (PAGE_SIZE),
  282.  "i" (Create_Dirty_Excl_D)
  283. :"$1","memory");
  284. }
  288. /*
  289.  * This is still inefficient.  We only can do better if we know the
  290.  * virtual address where the copy will be accessed.
  291.  */
  293. static void r5432_copy_page_d32(void * to, void * from)
  294. {
  295. unsigned long dummy1, dummy2;
  296. unsigned long reg1, reg2, reg3, reg4;
  298. __asm__ __volatile__(
  299. ".settnoreordernt"
  300. ".settnoatnt"
  301. ".settmips3nt"
  302. "daddiut$1,%0,%8n"
  303. "1:tcachet%9,(%0)nt"
  304. "lwt%2,(%1)nt"
  305. "lwt%3,4(%1)nt"
  306. "lwt%4,8(%1)nt"
  307. "lwt%5,12(%1)nt"
  308. "swt%2,(%0)nt"
  309. "swt%3,4(%0)nt"
  310. "swt%4,8(%0)nt"
  311. "swt%5,12(%0)nt"
  312. "lwt%2,16(%1)nt"
  313. "lwt%3,20(%1)nt"
  314. "lwt%4,24(%1)nt"
  315. "lwt%5,28(%1)nt"
  316. "swt%2,16(%0)nt"
  317. "swt%3,20(%0)nt"
  318. "swt%4,24(%0)nt"
  319. "swt%5,28(%0)nt"
  320. "cachet%9,32(%0)nt"
  321. "daddiut%0,64nt"
  322. "daddiut%1,64nt"
  323. "lwt%2,-32(%1)nt"
  324. "lwt%3,-28(%1)nt"
  325. "lwt%4,-24(%1)nt"
  326. "lwt%5,-20(%1)nt"
  327. "swt%2,-32(%0)nt"
  328. "swt%3,-28(%0)nt"
  329. "swt%4,-24(%0)nt"
  330. "swt%5,-20(%0)nt"
  331. "lwt%2,-16(%1)nt"
  332. "lwt%3,-12(%1)nt"
  333. "lwt%4,-8(%1)nt"
  334. "lwt%5,-4(%1)nt"
  335. "swt%2,-16(%0)nt"
  336. "swt%3,-12(%0)nt"
  337. "swt%4,-8(%0)nt"
  338. "bnet$1,%0,1bnt"
  339. "swt%5,-4(%0)nt"
  340. ".settmips0nt"
  341. ".settatnt"
  342. ".settreorder"
  343. :"=r" (dummy1), "=r" (dummy2),
  344.  "=&r" (reg1), "=&r" (reg2), "=&r" (reg3), "=&r" (reg4)
  345. :"0" (to), "1" (from),
  346.  "I" (PAGE_SIZE),
  347.  "i" (Create_Dirty_Excl_D));
  348. }
  351. /*
  352.  * If you think for one second that this stuff coming up is a lot
  353.  * of bulky code eating too many kernel cache lines.  Think _again_.
  354.  *
  355.  * Consider:
  356.  * 1) Taken branches have a 3 cycle penalty on R4k
  357.  * 2) The branch itself is a real dead cycle on even R4600/R5000.
  358.  * 3) Only one of the following variants of each type is even used by
  359.  *    the kernel based upon the cache parameters we detect at boot time.
  360.  *
  361.  * QED.
  362.  */
  364. static inline void r5432_flush_cache_all_d32i32(void)
  365. {
  366. blast_dcache32(); blast_icache32();
  367. }
  369. static void r5432_flush_cache_range_d32i32(struct mm_struct *mm,
  370.  unsigned long start,
  371.  unsigned long end)
  372. {
  373. if (mm->context != 0) {
  374. #ifdef DEBUG_CACHE
  375. printk("crange[%d,%08lx,%08lx]", (int)mm->context, start, end);
  376. #endif
  377. blast_dcache32(); blast_icache32();
  378. }
  379. }
  381. /*
  382.  * On architectures like the Sparc, we could get rid of lines in
  383.  * the cache created only by a certain context, but on the MIPS
  384.  * (and actually certain Sparc's) we cannot.
  385.  */
  386. static void r5432_flush_cache_mm_d32i32(struct mm_struct *mm)
  387. {
  388. if (mm->context != 0) {
  389. #ifdef DEBUG_CACHE
  390. printk("cmm[%d]", (int)mm->context);
  391. #endif
  392. r5432_flush_cache_all_d32i32();
  393. }
  394. }
  396. static void r5432_flush_cache_page_d32i32(struct vm_area_struct *vma,
  397. unsigned long page)
  398. {
  399. struct mm_struct *mm = vma->vm_mm;
  400. pgd_t *pgdp;
  401. pmd_t *pmdp;
  402. pte_t *ptep;
  404. /*
  405.  * If ownes no valid ASID yet, cannot possibly have gotten
  406.  * this page into the cache.
  407.  */
  408. if (mm->context == 0)
  409. return;
  411. #ifdef DEBUG_CACHE
  412. printk("cpage[%d,%08lx]", (int)mm->context, page);
  413. #endif
  414. page &= PAGE_MASK;
  415. pgdp = pgd_offset(mm, page);
  416. pmdp = pmd_offset(pgdp, page);
  417. ptep = pte_offset(pmdp, page);
  419. /*
  420.  * If the page isn't marked valid, the page cannot possibly be
  421.  * in the cache.
  422.  */
  423. if (!(pte_val(*ptep) & _PAGE_PRESENT))
  424. return;
  426. /*
  427.  * Doing flushes for another ASID than the current one is
  428.  * too difficult since stupid R4k caches do a TLB translation
  429.  * for every cache flush operation.  So we do indexed flushes
  430.  * in that case, which doesn't overly flush the cache too much.
  431.  */
  432. if ((mm == current->active_mm) && (pte_val(*ptep) & _PAGE_VALID)) {
  433. blast_dcache32_page(page);
  434. } else {
  435. /*
  436.  * Do indexed flush, too much work to get the (possible)
  437.  * tlb refills to work correctly.
  438.  */
  439. page = (KSEG0 + (page & (dcache_size - 1)));
  440. blast_dcache32_page_indexed(page);
  441. }
  442. }
  445. /* If the addresses passed to these routines are valid, they are
  446.  * either:
  447.  *
  448.  * 1) In KSEG0, so we can do a direct flush of the page.
  449.  * 2) In KSEG2, and since every process can translate those
  450.  *    addresses all the time in kernel mode we can do a direct
  451.  *    flush.
  452.  * 3) In KSEG1, no flush necessary.
  453.  */
  454. static void r5432_flush_page_to_ram_d32(struct page *page)
  455. {
  456. blast_dcache32_page((unsigned long)page_address(page));
  457. }
  459. static void 
  460. r5432_flush_icache_range(unsigned long start, unsigned long end)
  461. {
  462. r5432_flush_cache_all_d32i32();
  463. }
  465. /*
  466.  * Ok, this seriously sucks.  We use them to flush a user page but don't
  467.  * know the virtual address, so we have to blast away the whole icache
  468.  * which is significantly more expensive than the real thing.
  469.  */
  470. static void
  471. r5432_flush_icache_page_i32(struct vm_area_struct *vma, struct page *page)
  472. {
  473. if (!(vma->vm_flags & VM_EXEC))
  474. return;
  476. r5432_flush_cache_all_d32i32();
  477. }
  479. /*
  480.  * Writeback and invalidate the primary cache dcache before DMA.
  481.  */
  482. static void
  483. r5432_dma_cache_wback_inv_pc(unsigned long addr, unsigned long size)
  484. {
  485. unsigned long end, a;
  487. if (size >= dcache_size) {
  488. flush_cache_all();
  489. } else {
  490. a = addr & ~(dc_lsize - 1);
  491. end = (addr + size) & ~(dc_lsize - 1);
  492. while (1) {
  493. flush_dcache_line(a); /* Hit_Writeback_Inv_D */
  494. if (a == end) break;
  495. a += dc_lsize;
  496. }
  497. }
  498. bc_wback_inv(addr, size);
  499. }
  501. static void
  502. r5432_dma_cache_inv_pc(unsigned long addr, unsigned long size)
  503. {
  504. unsigned long end, a;
  506. if (size >= dcache_size) {
  507. flush_cache_all();
  508. } else {
  509. a = addr & ~(dc_lsize - 1);
  510. end = (addr + size) & ~(dc_lsize - 1);
  511. while (1) {
  512. flush_dcache_line(a); /* Hit_Writeback_Inv_D */
  513. if (a == end) break;
  514. a += dc_lsize;
  515. }
  516. }
  518. bc_inv(addr, size);
  519. }
  521. static void
  522. r5432_dma_cache_wback(unsigned long addr, unsigned long size)
  523. {
  524. panic("r5432_dma_cache called - should not happen.n");
  525. }
  527. /*
  528.  * While we're protected against bad userland addresses we don't care
  529.  * very much about what happens in that case.  Usually a segmentation
  530.  * fault will dump the process later on anyway ...
  531.  */
  532. static void r5432_flush_cache_sigtramp(unsigned long addr)
  533. {
  534. protected_writeback_dcache_line(addr & ~(dc_lsize - 1));
  535. protected_flush_icache_line(addr & ~(ic_lsize - 1));
  536. }
  538. #undef DEBUG_TLB
  539. #undef DEBUG_TLBUPDATE
  541. #define NTLB_ENTRIES       48  /* Fixed on all R4XX0 variants... */
  543. #define NTLB_ENTRIES_HALF  24  /* Fixed on all R4XX0 variants... */
  545. void flush_tlb_all(void)
  546. {
  547. unsigned long old_ctx;
  548. int entry;
  549. unsigned long flags;
  551. #ifdef DEBUG_TLB
  552. printk("[tlball]");
  553. #endif
  555. __save_and_cli(flags);
  556. /* Save old context and create impossible VPN2 value */
  557. old_ctx = (get_entryhi() & 0xff);
  558. set_entryhi(KSEG0);
  559. set_entrylo0(0);
  560. set_entrylo1(0);
  561. BARRIER;
  563. entry = get_wired();
  565. /* Blast 'em all away. */
  566. while(entry < NTLB_ENTRIES) {
  567. set_index(entry);
  568. BARRIER;
  569. tlb_write_indexed();
  570. BARRIER;
  571. entry++;
  572. }
  573. BARRIER;
  574. set_entryhi(old_ctx);
  575. __restore_flags(flags);
  576. }
  578. void flush_tlb_mm(struct mm_struct *mm)
  579. {
  580. if (mm->context != 0) {
  581. unsigned long flags;
  583. #ifdef DEBUG_TLB
  584. printk("[tlbmm<%d>]", mm->context);
  585. #endif
  586. __save_and_cli(flags);
  587. get_new_mmu_context(mm, asid_cache);
  588. if (mm == current->active_mm)
  589. set_entryhi(mm->context & 0xff);
  590. __restore_flags(flags);
  591. }
  592. }
  594. void flush_tlb_range(struct mm_struct *mm, unsigned long start,
  595. unsigned long end)
  596. {
  597. if(mm->context != 0) {
  598. unsigned long flags;
  599. int size;
  601. #ifdef DEBUG_TLB
  602. printk("[tlbrange<%02x,%08lx,%08lx>]", (mm->context & 0xff),
  603.        start, end);
  604. #endif
  605. __save_and_cli(flags);
  606. size = (end - start + (PAGE_SIZE - 1)) >> PAGE_SHIFT;
  607. size = (size + 1) >> 1;
  608. if(size <= NTLB_ENTRIES_HALF) {
  609. int oldpid = (get_entryhi() & 0xff);
  610. int newpid = (mm->context & 0xff);
  612. start &= (PAGE_MASK << 1);
  613. end += ((PAGE_SIZE << 1) - 1);
  614. end &= (PAGE_MASK << 1);
  615. while(start < end) {
  616. int idx;
  618. set_entryhi(start | newpid);
  619. start += (PAGE_SIZE << 1);
  620. BARRIER;
  621. tlb_probe();
  622. BARRIER;
  623. idx = get_index();
  624. set_entrylo0(0);
  625. set_entrylo1(0);
  626. set_entryhi(KSEG0);
  627. BARRIER;
  628. if(idx < 0)
  629. continue;
  630. tlb_write_indexed();
  631. BARRIER;
  632. }
  633. set_entryhi(oldpid);
  634. } else {
  635. get_new_mmu_context(mm, asid_cache);
  636. if (mm == current->active_mm)
  637. set_entryhi(mm->context & 0xff);
  638. }
  639. __restore_flags(flags);
  640. }
  641. }
  643. void flush_tlb_page(struct vm_area_struct *vma, unsigned long page)
  644. {
  645. if (vma->vm_mm->context != 0) {
  646. unsigned long flags;
  647. int oldpid, newpid, idx;
  649. #ifdef DEBUG_TLB
  650. printk("[tlbpage<%d,%08lx>]", vma->vm_mm->context, page);
  651. #endif
  652. newpid = (vma->vm_mm->context & 0xff);
  653. page &= (PAGE_MASK << 1);
  654. __save_and_cli(flags);
  655. oldpid = (get_entryhi() & 0xff);
  656. set_entryhi(page | newpid);
  657. BARRIER;
  658. tlb_probe();
  659. BARRIER;
  660. idx = get_index();
  661. set_entrylo0(0);
  662. set_entrylo1(0);
  663. set_entryhi(KSEG0);
  664. if(idx < 0)
  665. goto finish;
  666. BARRIER;
  667. tlb_write_indexed();
  669. finish:
  670. BARRIER;
  671. set_entryhi(oldpid);
  672. __restore_flags(flags);
  673. }
  674. }
  676. void pgd_init(unsigned long page)
  677. {
  678. unsigned long *p = (unsigned long *) page;
  679. int i;
  681. for(i = 0; i < USER_PTRS_PER_PGD; i+=8) {
  682. p[i + 0] = (unsigned long) invalid_pte_table;
  683. p[i + 1] = (unsigned long) invalid_pte_table;
  684. p[i + 2] = (unsigned long) invalid_pte_table;
  685. p[i + 3] = (unsigned long) invalid_pte_table;
  686. p[i + 4] = (unsigned long) invalid_pte_table;
  687. p[i + 5] = (unsigned long) invalid_pte_table;
  688. p[i + 6] = (unsigned long) invalid_pte_table;
  689. p[i + 7] = (unsigned long) invalid_pte_table;
  690. }
  691. }
  693. /* We will need multiple versions of update_mmu_cache(), one that just
  694.  * updates the TLB with the new pte(s), and another which also checks
  695.  * for the R4k "end of page" hardware bug and does the needy.
  696.  */
  697. void update_mmu_cache(struct vm_area_struct * vma,
  698.  unsigned long address, pte_t pte)
  699. {
  700. unsigned long flags;
  701. pgd_t *pgdp;
  702. pmd_t *pmdp;
  703. pte_t *ptep;
  704. int idx, pid;
  706. /*
  707.  * Handle debugger faulting in for debugee.
  708.  */
  709. if (current->active_mm != vma->vm_mm)
  710. return;
  712. pid = get_entryhi() & 0xff;
  714. #ifdef DEBUG_TLB
  715. if((pid != (vma->vm_mm->context & 0xff)) || (vma->vm_mm->context == 0)) {
  716. printk("update_mmu_cache: Wheee, bogus tlbpid mmpid=%d tlbpid=%dn",
  717.        (int) (vma->vm_mm->context & 0xff), pid);
  718. }
  719. #endif
  721. __save_and_cli(flags);
  722. address &= (PAGE_MASK << 1);
  723. set_entryhi(address | (pid));
  724. pgdp = pgd_offset(vma->vm_mm, address);
  725. BARRIER;
  726. tlb_probe();
  727. BARRIER;
  728. pmdp = pmd_offset(pgdp, address);
  729. idx = get_index();
  730. ptep = pte_offset(pmdp, address);
  731. BARRIER;
  732. set_entrylo0(pte_val(*ptep++) >> 6);
  733. set_entrylo1(pte_val(*ptep) >> 6);
  734. set_entryhi(address | (pid));
  735. BARRIER;
  736. if(idx < 0) {
  737. tlb_write_random();
  738. } else {
  739. tlb_write_indexed();
  740. }
  741. BARRIER;
  742. set_entryhi(pid);
  743. BARRIER;
  744. __restore_flags(flags);
  745. }
  747. void show_regs(struct pt_regs * regs)
  748. {
  749. /* Saved main processor registers. */
  750. printk("$0 : %08lx %08lx %08lx %08lxn",
  751.        0UL, regs->regs[1], regs->regs[2], regs->regs[3]);
  752. printk("$4 : %08lx %08lx %08lx %08lxn",
  753.                regs->regs[4], regs->regs[5], regs->regs[6], regs->regs[7]);
  754. printk("$8 : %08lx %08lx %08lx %08lxn",
  755.        regs->regs[8], regs->regs[9], regs->regs[10], regs->regs[11]);
  756. printk("$12: %08lx %08lx %08lx %08lxn",
  757.                regs->regs[12], regs->regs[13], regs->regs[14], regs->regs[15]);
  758. printk("$16: %08lx %08lx %08lx %08lxn",
  759.        regs->regs[16], regs->regs[17], regs->regs[18], regs->regs[19]);
  760. printk("$20: %08lx %08lx %08lx %08lxn",
  761.                regs->regs[20], regs->regs[21], regs->regs[22], regs->regs[23]);
  762. printk("$24: %08lx %08lxn",
  763.        regs->regs[24], regs->regs[25]);
  764. printk("$28: %08lx %08lx %08lx %08lxn",
  765.        regs->regs[28], regs->regs[29], regs->regs[30], regs->regs[31]);
  767. /* Saved cp0 registers. */
  768. printk("epc   : %08lx    %snStatus: %08lxnCause : %08lxn",
  769.        regs->cp0_epc, print_tainted(), regs->cp0_status, regs->cp0_cause);
  770. }
  772. void add_wired_entry(unsigned long entrylo0, unsigned long entrylo1,
  773.      unsigned long entryhi, unsigned long pagemask)
  774. {
  775.         unsigned long flags;
  776.         unsigned long wired;
  777.         unsigned long old_pagemask;
  778.         unsigned long old_ctx;
  780.         __save_and_cli(flags);
  781.         /* Save old context and create impossible VPN2 value */
  782.         old_ctx = (get_entryhi() & 0xff);
  783.         old_pagemask = get_pagemask();
  784.         wired = get_wired();
  785.         set_wired (wired + 1);
  786.         set_index (wired);
  787.         BARRIER;    
  788.         set_pagemask (pagemask);
  789.         set_entryhi(entryhi);
  790.         set_entrylo0(entrylo0);
  791.         set_entrylo1(entrylo1);
  792.         BARRIER;    
  793.         tlb_write_indexed();
  794.         BARRIER;    
  795.     
  796.         set_entryhi(old_ctx);
  797.         BARRIER;    
  798.         set_pagemask (old_pagemask);
  799.         flush_tlb_all();    
  800.         __restore_flags(flags);
  801. }
  803. /* Detect and size the various r4k caches. */
  804. static void __init probe_icache(unsigned long config)
  805. {
  806. icache_size = 1 << (12 + ((config >> 9) & 7));
  807. ic_lsize = 16 << ((config >> 5) & 1);
  809. printk("Primary instruction cache %dkb, linesize %d bytes.n",
  810.        icache_size >> 10, ic_lsize);
  811. }
  813. static void __init probe_dcache(unsigned long config)
  814. {
  815. dcache_size = 1 << (12 + ((config >> 6) & 7));
  816. dc_lsize = 16 << ((config >> 4) & 1);
  818. printk("Primary data cache %dkb, linesize %d bytes.n",
  819.        dcache_size >> 10, dc_lsize);
  820. }
  823. void __init ld_mmu_r5432(void)
  824. {
  825. unsigned long config = read_32bit_cp0_register(CP0_CONFIG);
  827. printk("CPU revision is: %08xn", read_32bit_cp0_register(CP0_PRID));
  829. change_cp0_config(CONF_CM_CMASK, CONF_CM_CACHABLE_NONCOHERENT);
  831. probe_icache(config);
  832. probe_dcache(config);
  834. _clear_page = r5432_clear_page_d32;
  835. _copy_page = r5432_copy_page_d32;
  836. _flush_cache_all = r5432_flush_cache_all_d32i32;
  837. ___flush_cache_all = r5432_flush_cache_all_d32i32;
  838. _flush_page_to_ram = r5432_flush_page_to_ram_d32;
  839. _flush_cache_mm = r5432_flush_cache_mm_d32i32;
  840. _flush_cache_range = r5432_flush_cache_range_d32i32;
  841. _flush_cache_page = r5432_flush_cache_page_d32i32;
  842. _flush_icache_page = r5432_flush_icache_page_i32;
  843. _dma_cache_wback_inv = r5432_dma_cache_wback_inv_pc;
  844. _dma_cache_wback = r5432_dma_cache_wback;
  845. _dma_cache_inv = r5432_dma_cache_inv_pc;
  847. _flush_cache_sigtramp = r5432_flush_cache_sigtramp;
  848. _flush_icache_range = r5432_flush_icache_range; /* Ouch */
  850. __flush_cache_all();
  851. write_32bit_cp0_register(CP0_WIRED, 0);
  853. /*
  854.  * You should never change this register:
  855.  *   - On R4600 1.7 the tlbp never hits for pages smaller than
  856.  *     the value in the c0_pagemask register.
  857.  *   - The entire mm handling assumes the c0_pagemask register to
  858.  *     be set for 4kb pages.
  859.  */
  860. write_32bit_cp0_register(CP0_PAGEMASK, PM_4K);
  861. flush_tlb_all();
  862. }