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

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

Linux/Unix编程

开发平台：

Unix_Linux

c-r4k.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.  * r4xx0.c: R4000 processor variant specific MMU/Cache routines.
  7.  *
  8.  * Copyright (C) 1996 David S. Miller (dm@engr.sgi.com)
  9.  * Copyright (C) 1997, 1998, 1999, 2000 Ralf Baechle ralf@gnu.org
  10.  *
  11.  * To do:
  12.  *
  13.  *  - this code is a overbloated pig
  14.  *  - many of the bug workarounds are not efficient at all, but at
  15.  *    least they are functional ...
  16.  */
  17. #include <linux/config.h>
  18. #include <linux/init.h>
  19. #include <linux/kernel.h>
  20. #include <linux/sched.h>
  21. #include <linux/mm.h>
  23. #include <asm/bootinfo.h>
  24. #include <asm/cpu.h>
  25. #include <asm/bcache.h>
  26. #include <asm/io.h>
  27. #include <asm/page.h>
  28. #include <asm/pgtable.h>
  29. #include <asm/system.h>
  30. #include <asm/mmu_context.h>
  31. #include <asm/war.h>
  33. /* Primary cache parameters. */
  34. static int icache_size, dcache_size; /* Size in bytes */
  35. static int ic_lsize, dc_lsize;       /* LineSize in bytes */
  37. /* Secondary cache (if present) parameters. */
  38. static unsigned int scache_size, sc_lsize; /* Again, in bytes */
  40. #include <asm/cacheops.h>
  41. #include <asm/r4kcache.h>
  43. #undef DEBUG_CACHE
  45. /*
  46.  * Dummy cache handling routines for machines without boardcaches
  47.  */
  48. static void no_sc_noop(void) {}
  50. static struct bcache_ops no_sc_ops = {
  51. (void *)no_sc_noop, (void *)no_sc_noop,
  52. (void *)no_sc_noop, (void *)no_sc_noop
  53. };
  55. struct bcache_ops *bcops = &no_sc_ops;
  57. /*
  58.  * On processors with QED R4600 style two set assosicative cache
  59.  * this is the bit which selects the way in the cache for the
  60.  * indexed cachops.
  61.  */
  62. #define icache_waybit (icache_size >> 1)
  63. #define dcache_waybit (dcache_size >> 1)
  65. /*
  66.  * If you think for one second that this stuff coming up is a lot
  67.  * of bulky code eating too many kernel cache lines.  Think _again_.
  68.  *
  69.  * Consider:
  70.  * 1) Taken branches have a 3 cycle penalty on R4k
  71.  * 2) The branch itself is a real dead cycle on even R4600/R5000.
  72.  * 3) Only one of the following variants of each type is even used by
  73.  *    the kernel based upon the cache parameters we detect at boot time.
  74.  *
  75.  * QED.
  76.  */
  78. static inline void r4k_flush_cache_all_s16d16i16(void)
  79. {
  80. blast_dcache16(); blast_icache16(); blast_scache16();
  81. }
  83. static inline void r4k_flush_cache_all_s32d16i16(void)
  84. {
  85. blast_dcache16(); blast_icache16(); blast_scache32();
  86. }
  88. static inline void r4k_flush_cache_all_s64d16i16(void)
  89. {
  90. blast_dcache16(); blast_icache16(); blast_scache64();
  91. }
  93. static inline void r4k_flush_cache_all_s128d16i16(void)
  94. {
  95. blast_dcache16(); blast_icache16(); blast_scache128();
  96. }
  98. static inline void r4k_flush_cache_all_s32d32i32(void)
  99. {
  100. blast_dcache32(); blast_icache32(); blast_scache32();
  101. }
  103. static inline void r4k_flush_cache_all_s64d32i32(void)
  104. {
  105. blast_dcache32(); blast_icache32(); blast_scache64();
  106. }
  108. static inline void r4k_flush_cache_all_s128d32i32(void)
  109. {
  110. blast_dcache32(); blast_icache32(); blast_scache128();
  111. }
  113. static inline void r4k_flush_cache_all_d16i16(void)
  114. {
  115. blast_dcache16(); blast_icache16();
  116. }
  118. static inline void r4k_flush_cache_all_d32i32(void)
  119. {
  120. blast_dcache32(); blast_icache32();
  121. }
  123. static void
  124. r4k_flush_cache_range_s16d16i16(struct mm_struct *mm,
  125.                                 unsigned long start,
  126.                                 unsigned long end)
  127. {
  128. struct vm_area_struct *vma;
  130. if (mm->context == 0)
  131. return;
  133. start &= PAGE_MASK;
  134. #ifdef DEBUG_CACHE
  135. printk("crange[%d,%08lx,%08lx]", (int)mm->context, start, end);
  136. #endif
  137. vma = find_vma(mm, start);
  138. if (vma) {
  139. if (mm->context != current->active_mm->context) {
  140. r4k_flush_cache_all_s16d16i16();
  141. } else {
  142. pgd_t *pgd;
  143. pmd_t *pmd;
  144. pte_t *pte;
  146. while (start < end) {
  147. pgd = pgd_offset(mm, start);
  148. pmd = pmd_offset(pgd, start);
  149. pte = pte_offset(pmd, start);
  151. if(pte_val(*pte) & _PAGE_VALID)
  152. blast_scache16_page(start);
  153. start += PAGE_SIZE;
  154. }
  155. }
  156. }
  157. }
  159. static void
  160. r4k_flush_cache_range_s32d16i16(struct mm_struct *mm,
  161.                                 unsigned long start,
  162.                                 unsigned long end)
  163. {
  164. struct vm_area_struct *vma;
  166. if (mm->context == 0)
  167. return;
  169. start &= PAGE_MASK;
  170. #ifdef DEBUG_CACHE
  171. printk("crange[%d,%08lx,%08lx]", (int)mm->context, start, end);
  172. #endif
  173. vma = find_vma(mm, start);
  174. if (vma) {
  175. if (mm->context != current->active_mm->context) {
  176. r4k_flush_cache_all_s32d16i16();
  177. } else {
  178. pgd_t *pgd;
  179. pmd_t *pmd;
  180. pte_t *pte;
  182. while(start < end) {
  183. pgd = pgd_offset(mm, start);
  184. pmd = pmd_offset(pgd, start);
  185. pte = pte_offset(pmd, start);
  187. if(pte_val(*pte) & _PAGE_VALID)
  188. blast_scache32_page(start);
  189. start += PAGE_SIZE;
  190. }
  191. }
  192. }
  193. }
  195. static void r4k_flush_cache_range_s64d16i16(struct mm_struct *mm,
  196.     unsigned long start,
  197.     unsigned long end)
  198. {
  199. struct vm_area_struct *vma;
  201. if (mm->context == 0)
  202. return;
  204. start &= PAGE_MASK;
  205. #ifdef DEBUG_CACHE
  206. printk("crange[%d,%08lx,%08lx]", (int)mm->context, start, end);
  207. #endif
  208. vma = find_vma(mm, start);
  209. if(vma) {
  210. if (mm->context != current->active_mm->context) {
  211. r4k_flush_cache_all_s64d16i16();
  212. } else {
  213. pgd_t *pgd;
  214. pmd_t *pmd;
  215. pte_t *pte;
  217. while(start < end) {
  218. pgd = pgd_offset(mm, start);
  219. pmd = pmd_offset(pgd, start);
  220. pte = pte_offset(pmd, start);
  222. if(pte_val(*pte) & _PAGE_VALID)
  223. blast_scache64_page(start);
  224. start += PAGE_SIZE;
  225. }
  226. }
  227. }
  228. }
  230. static void r4k_flush_cache_range_s128d16i16(struct mm_struct *mm,
  231.      unsigned long start,
  232.      unsigned long end)
  233. {
  234. struct vm_area_struct *vma;
  236. if (mm->context == 0)
  237. return;
  239. start &= PAGE_MASK;
  240. #ifdef DEBUG_CACHE
  241. printk("crange[%d,%08lx,%08lx]", (int)mm->context, start, end);
  242. #endif
  243. vma = find_vma(mm, start);
  244. if (vma) {
  245. if (mm->context != current->active_mm->context) {
  246. r4k_flush_cache_all_s128d16i16();
  247. } else {
  248. pgd_t *pgd;
  249. pmd_t *pmd;
  250. pte_t *pte;
  252. while(start < end) {
  253. pgd = pgd_offset(mm, start);
  254. pmd = pmd_offset(pgd, start);
  255. pte = pte_offset(pmd, start);
  257. if(pte_val(*pte) & _PAGE_VALID)
  258. blast_scache128_page(start);
  259. start += PAGE_SIZE;
  260. }
  261. }
  262. }
  263. }
  265. static void r4k_flush_cache_range_s32d32i32(struct mm_struct *mm,
  266.     unsigned long start,
  267.     unsigned long end)
  268. {
  269. struct vm_area_struct *vma;
  271. if (mm->context == 0)
  272. return;
  274. start &= PAGE_MASK;
  275. #ifdef DEBUG_CACHE
  276. printk("crange[%d,%08lx,%08lx]", (int)mm->context, start, end);
  277. #endif
  278. vma = find_vma(mm, start);
  279. if (vma) {
  280. if (mm->context != current->active_mm->context) {
  281. r4k_flush_cache_all_s32d32i32();
  282. } else {
  283. pgd_t *pgd;
  284. pmd_t *pmd;
  285. pte_t *pte;
  287. while(start < end) {
  288. pgd = pgd_offset(mm, start);
  289. pmd = pmd_offset(pgd, start);
  290. pte = pte_offset(pmd, start);
  292. if(pte_val(*pte) & _PAGE_VALID)
  293. blast_scache32_page(start);
  294. start += PAGE_SIZE;
  295. }
  296. }
  297. }
  298. }
  300. static void r4k_flush_cache_range_s64d32i32(struct mm_struct *mm,
  301.     unsigned long start,
  302.     unsigned long end)
  303. {
  304. struct vm_area_struct *vma;
  306. if (mm->context == 0)
  307. return;
  309. start &= PAGE_MASK;
  310. #ifdef DEBUG_CACHE
  311. printk("crange[%d,%08lx,%08lx]", (int)mm->context, start, end);
  312. #endif
  313. vma = find_vma(mm, start);
  314. if (vma) {
  315. if (mm->context != current->active_mm->context) {
  316. r4k_flush_cache_all_s64d32i32();
  317. } else {
  318. pgd_t *pgd;
  319. pmd_t *pmd;
  320. pte_t *pte;
  322. while(start < end) {
  323. pgd = pgd_offset(mm, start);
  324. pmd = pmd_offset(pgd, start);
  325. pte = pte_offset(pmd, start);
  327. if(pte_val(*pte) & _PAGE_VALID)
  328. blast_scache64_page(start);
  329. start += PAGE_SIZE;
  330. }
  331. }
  332. }
  333. }
  335. static void r4k_flush_cache_range_s128d32i32(struct mm_struct *mm,
  336.      unsigned long start,
  337.      unsigned long end)
  338. {
  339. struct vm_area_struct *vma;
  341. if (mm->context == 0)
  342. return;
  344. start &= PAGE_MASK;
  345. #ifdef DEBUG_CACHE
  346. printk("crange[%d,%08lx,%08lx]", (int)mm->context, start, end);
  347. #endif
  348. vma = find_vma(mm, start);
  349. if (vma) {
  350. if (mm->context != current->active_mm->context) {
  351. r4k_flush_cache_all_s128d32i32();
  352. } else {
  353. pgd_t *pgd;
  354. pmd_t *pmd;
  355. pte_t *pte;
  357. while(start < end) {
  358. pgd = pgd_offset(mm, start);
  359. pmd = pmd_offset(pgd, start);
  360. pte = pte_offset(pmd, start);
  362. if(pte_val(*pte) & _PAGE_VALID)
  363. blast_scache128_page(start);
  364. start += PAGE_SIZE;
  365. }
  366. }
  367. }
  368. }
  370. static void r4k_flush_cache_range_d16i16(struct mm_struct *mm,
  371.  unsigned long start,
  372.  unsigned long end)
  373. {
  374. if (mm->context != 0) {
  375. #ifdef DEBUG_CACHE
  376. printk("crange[%d,%08lx,%08lx]", (int)mm->context, start, end);
  377. #endif
  378. blast_dcache16(); blast_icache16();
  379. }
  380. }
  382. static void r4k_flush_cache_range_d32i32(struct mm_struct *mm,
  383.  unsigned long start,
  384.  unsigned long end)
  385. {
  386. if (mm->context != 0) {
  387. #ifdef DEBUG_CACHE
  388. printk("crange[%d,%08lx,%08lx]", (int)mm->context, start, end);
  389. #endif
  390. blast_dcache32(); blast_icache32();
  391. }
  392. }
  394. /*
  395.  * On architectures like the Sparc, we could get rid of lines in
  396.  * the cache created only by a certain context, but on the MIPS
  397.  * (and actually certain Sparc's) we cannot.
  398.  */
  399. static void r4k_flush_cache_mm_s16d16i16(struct mm_struct *mm)
  400. {
  401. if (mm->context != 0) {
  402. #ifdef DEBUG_CACHE
  403. printk("cmm[%d]", (int)mm->context);
  404. #endif
  405. r4k_flush_cache_all_s16d16i16();
  406. }
  407. }
  409. static void r4k_flush_cache_mm_s32d16i16(struct mm_struct *mm)
  410. {
  411. if (mm->context != 0) {
  412. #ifdef DEBUG_CACHE
  413. printk("cmm[%d]", (int)mm->context);
  414. #endif
  415. r4k_flush_cache_all_s32d16i16();
  416. }
  417. }
  419. static void r4k_flush_cache_mm_s64d16i16(struct mm_struct *mm)
  420. {
  421. if (mm->context != 0) {
  422. #ifdef DEBUG_CACHE
  423. printk("cmm[%d]", (int)mm->context);
  424. #endif
  425. r4k_flush_cache_all_s64d16i16();
  426. }
  427. }
  429. static void r4k_flush_cache_mm_s128d16i16(struct mm_struct *mm)
  430. {
  431. if (mm->context != 0) {
  432. #ifdef DEBUG_CACHE
  433. printk("cmm[%d]", (int)mm->context);
  434. #endif
  435. r4k_flush_cache_all_s128d16i16();
  436. }
  437. }
  439. static void r4k_flush_cache_mm_s32d32i32(struct mm_struct *mm)
  440. {
  441. if (mm->context != 0) {
  442. #ifdef DEBUG_CACHE
  443. printk("cmm[%d]", (int)mm->context);
  444. #endif
  445. r4k_flush_cache_all_s32d32i32();
  446. }
  447. }
  449. static void r4k_flush_cache_mm_s64d32i32(struct mm_struct *mm)
  450. {
  451. if (mm->context != 0) {
  452. #ifdef DEBUG_CACHE
  453. printk("cmm[%d]", (int)mm->context);
  454. #endif
  455. r4k_flush_cache_all_s64d32i32();
  456. }
  457. }
  459. static void r4k_flush_cache_mm_s128d32i32(struct mm_struct *mm)
  460. {
  461. if (mm->context != 0) {
  462. #ifdef DEBUG_CACHE
  463. printk("cmm[%d]", (int)mm->context);
  464. #endif
  465. r4k_flush_cache_all_s128d32i32();
  466. }
  467. }
  469. static void r4k_flush_cache_mm_d16i16(struct mm_struct *mm)
  470. {
  471. if (mm->context != 0) {
  472. #ifdef DEBUG_CACHE
  473. printk("cmm[%d]", (int)mm->context);
  474. #endif
  475. r4k_flush_cache_all_d16i16();
  476. }
  477. }
  479. static void r4k_flush_cache_mm_d32i32(struct mm_struct *mm)
  480. {
  481. if (mm->context != 0) {
  482. #ifdef DEBUG_CACHE
  483. printk("cmm[%d]", (int)mm->context);
  484. #endif
  485. r4k_flush_cache_all_d32i32();
  486. }
  487. }
  489. static void r4k_flush_cache_page_s16d16i16(struct vm_area_struct *vma,
  490.    unsigned long page)
  491. {
  492. struct mm_struct *mm = vma->vm_mm;
  493. pgd_t *pgdp;
  494. pmd_t *pmdp;
  495. pte_t *ptep;
  497. /*
  498.  * If ownes no valid ASID yet, cannot possibly have gotten
  499.  * this page into the cache.
  500.  */
  501. if (mm->context == 0)
  502. return;
  504. #ifdef DEBUG_CACHE
  505. printk("cpage[%d,%08lx]", (int)mm->context, page);
  506. #endif
  507. page &= PAGE_MASK;
  508. pgdp = pgd_offset(mm, page);
  509. pmdp = pmd_offset(pgdp, page);
  510. ptep = pte_offset(pmdp, page);
  512. /*
  513.  * If the page isn't marked valid, the page cannot possibly be
  514.  * in the cache.
  515.  */
  516. if (!(pte_val(*ptep) & _PAGE_VALID))
  517. goto out;
  519. /*
  520.  * Doing flushes for another ASID than the current one is
  521.  * too difficult since stupid R4k caches do a TLB translation
  522.  * for every cache flush operation.  So we do indexed flushes
  523.  * in that case, which doesn't overly flush the cache too much.
  524.  */
  525. if (mm->context != current->active_mm->context) {
  526. /*
  527.  * Do indexed flush, too much work to get the (possible)
  528.  * tlb refills to work correctly.
  529.  */
  530. page = (KSEG0 + (page & (scache_size - 1)));
  531. blast_dcache16_page_indexed(page);
  532. blast_scache16_page_indexed(page);
  533. } else
  534. blast_scache16_page(page);
  535. out:
  536. }
  538. static void r4k_flush_cache_page_s32d16i16(struct vm_area_struct *vma,
  539.    unsigned long page)
  540. {
  541. struct mm_struct *mm = vma->vm_mm;
  542. pgd_t *pgdp;
  543. pmd_t *pmdp;
  544. pte_t *ptep;
  546. /*
  547.  * If ownes no valid ASID yet, cannot possibly have gotten
  548.  * this page into the cache.
  549.  */
  550. if (mm->context == 0)
  551. return;
  553. #ifdef DEBUG_CACHE
  554. printk("cpage[%d,%08lx]", (int)mm->context, page);
  555. #endif
  556. page &= PAGE_MASK;
  557. pgdp = pgd_offset(mm, page);
  558. pmdp = pmd_offset(pgdp, page);
  559. ptep = pte_offset(pmdp, page);
  561. /* If the page isn't marked valid, the page cannot possibly be
  562.  * in the cache.
  563.  */
  564. if (!(pte_val(*ptep) & _PAGE_VALID))
  565. goto out;
  567. /*
  568.  * Doing flushes for another ASID than the current one is
  569.  * too difficult since stupid R4k caches do a TLB translation
  570.  * for every cache flush operation.  So we do indexed flushes
  571.  * in that case, which doesn't overly flush the cache too much.
  572.  */
  573. if (mm->context != current->active_mm->context) {
  574. /*
  575.  * Do indexed flush, too much work to get the (possible)
  576.  * tlb refills to work correctly.
  577.  */
  578. page = (KSEG0 + (page & (scache_size - 1)));
  579. blast_dcache16_page_indexed(page);
  580. blast_scache32_page_indexed(page);
  581. } else
  582. blast_scache32_page(page);
  583. out:
  584. }
  586. static void r4k_flush_cache_page_s64d16i16(struct vm_area_struct *vma,
  587.    unsigned long page)
  588. {
  589. struct mm_struct *mm = vma->vm_mm;
  590. pgd_t *pgdp;
  591. pmd_t *pmdp;
  592. pte_t *ptep;
  594. /*
  595.  * If ownes no valid ASID yet, cannot possibly have gotten
  596.  * this page into the cache.
  597.  */
  598. if (mm->context == 0)
  599. return;
  601. #ifdef DEBUG_CACHE
  602. printk("cpage[%d,%08lx]", (int)mm->context, page);
  603. #endif
  604. page &= PAGE_MASK;
  605. pgdp = pgd_offset(mm, page);
  606. pmdp = pmd_offset(pgdp, page);
  607. ptep = pte_offset(pmdp, page);
  609. /* If the page isn't marked valid, the page cannot possibly be
  610.  * in the cache.
  611.  */
  612. if (!(pte_val(*ptep) & _PAGE_VALID))
  613. goto out;
  615. /*
  616.  * Doing flushes for another ASID than the current one is
  617.  * too difficult since stupid R4k caches do a TLB translation
  618.  * for every cache flush operation.  So we do indexed flushes
  619.  * in that case, which doesn't overly flush the cache too much.
  620.  */
  621. if (mm->context != current->active_mm->context) {
  622. /*
  623.  * Do indexed flush, too much work to get the (possible)
  624.  * tlb refills to work correctly.
  625.  */
  626. page = (KSEG0 + (page & (scache_size - 1)));
  627. blast_dcache16_page_indexed(page);
  628. blast_scache64_page_indexed(page);
  629. } else
  630. blast_scache64_page(page);
  631. out:
  632. }
  634. static void r4k_flush_cache_page_s128d16i16(struct vm_area_struct *vma,
  635.     unsigned long page)
  636. {
  637. struct mm_struct *mm = vma->vm_mm;
  638. pgd_t *pgdp;
  639. pmd_t *pmdp;
  640. pte_t *ptep;
  642. /*
  643.  * If ownes no valid ASID yet, cannot possibly have gotten
  644.  * this page into the cache.
  645.  */
  646. if (mm->context == 0)
  647. return;
  649. #ifdef DEBUG_CACHE
  650. printk("cpage[%d,%08lx]", (int)mm->context, page);
  651. #endif
  652. page &= PAGE_MASK;
  653. pgdp = pgd_offset(mm, page);
  654. pmdp = pmd_offset(pgdp, page);
  655. ptep = pte_offset(pmdp, page);
  657. /*
  658.  * If the page isn't marked valid, the page cannot possibly be
  659.  * in the cache.
  660.  */
  661. if (!(pte_val(*ptep) & _PAGE_VALID))
  662. goto out;
  664. /*
  665.  * Doing flushes for another ASID than the current one is
  666.  * too difficult since stupid R4k caches do a TLB translation
  667.  * for every cache flush operation.  So we do indexed flushes
  668.  * in that case, which doesn't overly flush the cache too much.
  669.  */
  670. if (mm->context != current->active_mm->context) {
  671. /*
  672.  * Do indexed flush, too much work to get the (possible)
  673.  * tlb refills to work correctly.
  674.  */
  675. page = (KSEG0 + (page & (scache_size - 1)));
  676. blast_dcache16_page_indexed(page);
  677. blast_scache128_page_indexed(page);
  678. } else
  679. blast_scache128_page(page);
  680. out:
  681. }
  683. static void r4k_flush_cache_page_s32d32i32(struct vm_area_struct *vma,
  684.    unsigned long page)
  685. {
  686. struct mm_struct *mm = vma->vm_mm;
  687. pgd_t *pgdp;
  688. pmd_t *pmdp;
  689. pte_t *ptep;
  691. /*
  692.  * If ownes no valid ASID yet, cannot possibly have gotten
  693.  * this page into the cache.
  694.  */
  695. if (mm->context == 0)
  696. return;
  698. #ifdef DEBUG_CACHE
  699. printk("cpage[%d,%08lx]", (int)mm->context, page);
  700. #endif
  701. page &= PAGE_MASK;
  702. pgdp = pgd_offset(mm, page);
  703. pmdp = pmd_offset(pgdp, page);
  704. ptep = pte_offset(pmdp, page);
  706. /*
  707.  * If the page isn't marked valid, the page cannot possibly be
  708.  * in the cache.
  709.  */
  710. if (!(pte_val(*ptep) & _PAGE_VALID))
  711. goto out;
  713. /*
  714.  * Doing flushes for another ASID than the current one is
  715.  * too difficult since stupid R4k caches do a TLB translation
  716.  * for every cache flush operation.  So we do indexed flushes
  717.  * in that case, which doesn't overly flush the cache too much.
  718.  */
  719. if (mm->context != current->active_mm->context) {
  720. /*
  721.  * Do indexed flush, too much work to get the (possible)
  722.  * tlb refills to work correctly.
  723.  */
  724. page = (KSEG0 + (page & (scache_size - 1)));
  725. blast_dcache32_page_indexed(page);
  726. blast_scache32_page_indexed(page);
  727. } else
  728. blast_scache32_page(page);
  729. out:
  730. }
  732. static void r4k_flush_cache_page_s64d32i32(struct vm_area_struct *vma,
  733.    unsigned long page)
  734. {
  735. struct mm_struct *mm = vma->vm_mm;
  736. pgd_t *pgdp;
  737. pmd_t *pmdp;
  738. pte_t *ptep;
  740. /*
  741.  * If ownes no valid ASID yet, cannot possibly have gotten
  742.  * this page into the cache.
  743.  */
  744. if (mm->context == 0)
  745. return;
  747. #ifdef DEBUG_CACHE
  748. printk("cpage[%d,%08lx]", (int)mm->context, page);
  749. #endif
  750. page &= PAGE_MASK;
  751. pgdp = pgd_offset(mm, page);
  752. pmdp = pmd_offset(pgdp, page);
  753. ptep = pte_offset(pmdp, page);
  755. /*
  756.  * If the page isn't marked valid, the page cannot possibly be
  757.  * in the cache.
  758.  */
  759. if (!(pte_val(*ptep) & _PAGE_VALID))
  760. goto out;
  762. /*
  763.  * Doing flushes for another ASID than the current one is
  764.  * too difficult since stupid R4k caches do a TLB translation
  765.  * for every cache flush operation.  So we do indexed flushes
  766.  * in that case, which doesn't overly flush the cache too much.
  767.  */
  768. if (mm->context != current->active_mm->context) {
  769. /*
  770.  * Do indexed flush, too much work to get the (possible)
  771.  * tlb refills to work correctly.
  772.  */
  773. page = (KSEG0 + (page & (scache_size - 1)));
  774. blast_dcache32_page_indexed(page);
  775. blast_scache64_page_indexed(page);
  776. } else
  777. blast_scache64_page(page);
  778. out:
  779. }
  781. static void r4k_flush_cache_page_s128d32i32(struct vm_area_struct *vma,
  782.     unsigned long page)
  783. {
  784. struct mm_struct *mm = vma->vm_mm;
  785. pgd_t *pgdp;
  786. pmd_t *pmdp;
  787. pte_t *ptep;
  789. /*
  790.  * If ownes no valid ASID yet, cannot possibly have gotten
  791.  * this page into the cache.
  792.  */
  793. if (mm->context == 0)
  794. return;
  796. #ifdef DEBUG_CACHE
  797. printk("cpage[%d,%08lx]", (int)mm->context, page);
  798. #endif
  799. page &= PAGE_MASK;
  800. pgdp = pgd_offset(mm, page);
  801. pmdp = pmd_offset(pgdp, page);
  802. ptep = pte_offset(pmdp, page);
  804. /*
  805.  * If the page isn't marked valid, the page cannot possibly be
  806.  * in the cache.
  807.  */
  808. if (!(pte_val(*ptep) & _PAGE_VALID))
  809. goto out;
  811. /*
  812.  * Doing flushes for another ASID than the current one is
  813.  * too difficult since stupid R4k caches do a TLB translation
  814.  * for every cache flush operation.  So we do indexed flushes
  815.  * in that case, which doesn't overly flush the cache too much.
  816.  */
  817. if (mm->context != current->active_mm->context) {
  818. /* Do indexed flush, too much work to get the (possible)
  819.  * tlb refills to work correctly.
  820.  */
  821. page = (KSEG0 + (page & (scache_size - 1)));
  822. blast_dcache32_page_indexed(page);
  823. blast_scache128_page_indexed(page);
  824. } else
  825. blast_scache128_page(page);
  826. out:
  827. }
  829. static void r4k_flush_cache_page_d16i16(struct vm_area_struct *vma,
  830. unsigned long page)
  831. {
  832. struct mm_struct *mm = vma->vm_mm;
  833. pgd_t *pgdp;
  834. pmd_t *pmdp;
  835. pte_t *ptep;
  837. /*
  838.  * If ownes no valid ASID yet, cannot possibly have gotten
  839.  * this page into the cache.
  840.  */
  841. if (mm->context == 0)
  842. return;
  844. #ifdef DEBUG_CACHE
  845. printk("cpage[%d,%08lx]", (int)mm->context, page);
  846. #endif
  847. page &= PAGE_MASK;
  848. pgdp = pgd_offset(mm, page);
  849. pmdp = pmd_offset(pgdp, page);
  850. ptep = pte_offset(pmdp, page);
  852. /*
  853.  * If the page isn't marked valid, the page cannot possibly be
  854.  * in the cache.
  855.  */
  856. if (!(pte_val(*ptep) & _PAGE_VALID))
  857. goto out;
  859. /*
  860.  * Doing flushes for another ASID than the current one is
  861.  * too difficult since stupid R4k caches do a TLB translation
  862.  * for every cache flush operation.  So we do indexed flushes
  863.  * in that case, which doesn't overly flush the cache too much.
  864.  */
  865. if (mm == current->active_mm) {
  866. blast_dcache16_page(page);
  867. } else {
  868. /* Do indexed flush, too much work to get the (possible)
  869.  * tlb refills to work correctly.
  870.  */
  871. page = (KSEG0 + (page & (dcache_size - 1)));
  872. blast_dcache16_page_indexed(page);
  873. }
  874. out:
  875. }
  877. static void r4k_flush_cache_page_d32i32(struct vm_area_struct *vma,
  878. unsigned long page)
  879. {
  880. struct mm_struct *mm = vma->vm_mm;
  881. pgd_t *pgdp;
  882. pmd_t *pmdp;
  883. pte_t *ptep;
  885. /*
  886.  * If ownes no valid ASID yet, cannot possibly have gotten
  887.  * this page into the cache.
  888.  */
  889. if (mm->context == 0)
  890. return;
  892. #ifdef DEBUG_CACHE
  893. printk("cpage[%d,%08lx]", (int)mm->context, page);
  894. #endif
  895. page &= PAGE_MASK;
  896. pgdp = pgd_offset(mm, page);
  897. pmdp = pmd_offset(pgdp, page);
  898. ptep = pte_offset(pmdp, page);
  900. /*
  901.  * If the page isn't marked valid, the page cannot possibly be
  902.  * in the cache.
  903.  */
  904. if (!(pte_val(*ptep) & _PAGE_PRESENT))
  905. goto out;
  907. /*
  908.  * Doing flushes for another ASID than the current one is
  909.  * too difficult since stupid R4k caches do a TLB translation
  910.  * for every cache flush operation.  So we do indexed flushes
  911.  * in that case, which doesn't overly flush the cache too much.
  912.  */
  913. if ((mm == current->active_mm) && (pte_val(*ptep) & _PAGE_VALID)) {
  914. blast_dcache32_page(page);
  915. } else {
  916. /*
  917.  * Do indexed flush, too much work to get the (possible)
  918.  * tlb refills to work correctly.
  919.  */
  920. page = (KSEG0 + (page & (dcache_size - 1)));
  921. blast_dcache32_page_indexed(page);
  922. }
  923. out:
  924. }
  926. static void r4k_flush_cache_page_d32i32_r4600(struct vm_area_struct *vma,
  927.       unsigned long page)
  928. {
  929. struct mm_struct *mm = vma->vm_mm;
  930. pgd_t *pgdp;
  931. pmd_t *pmdp;
  932. pte_t *ptep;
  934. /*
  935.  * If ownes no valid ASID yet, cannot possibly have gotten
  936.  * this page into the cache.
  937.  */
  938. if (mm->context == 0)
  939. return;
  941. #ifdef DEBUG_CACHE
  942. printk("cpage[%d,%08lx]", (int)mm->context, page);
  943. #endif
  944. page &= PAGE_MASK;
  945. pgdp = pgd_offset(mm, page);
  946. pmdp = pmd_offset(pgdp, page);
  947. ptep = pte_offset(pmdp, page);
  949. /*
  950.  * If the page isn't marked valid, the page cannot possibly be
  951.  * in the cache.
  952.  */
  953. if (!(pte_val(*ptep) & _PAGE_PRESENT))
  954. goto out;
  956. /*
  957.  * Doing flushes for another ASID than the current one is
  958.  * too difficult since stupid R4k caches do a TLB translation
  959.  * for every cache flush operation.  So we do indexed flushes
  960.  * in that case, which doesn't overly flush the cache too much.
  961.  */
  962. if ((mm == current->active_mm) && (pte_val(*ptep) & _PAGE_VALID)) {
  963. blast_dcache32_page(page);
  964. } else {
  965. /* Do indexed flush, too much work to get the (possible)
  966.  * tlb refills to work correctly.
  967.  */
  968. page = (KSEG0 + (page & (dcache_size - 1)));
  969. blast_dcache32_page_indexed(page);
  970. blast_dcache32_page_indexed(page ^ dcache_waybit);
  971. }
  972. out:
  973. }
  975. /* If the addresses passed to these routines are valid, they are
  976.  * either:
  977.  *
  978.  * 1) In KSEG0, so we can do a direct flush of the page.
  979.  * 2) In KSEG2, and since every process can translate those
  980.  *    addresses all the time in kernel mode we can do a direct
  981.  *    flush.
  982.  * 3) In KSEG1, no flush necessary.
  983.  */
  984. static void r4k_flush_page_to_ram_s16(struct page *page)
  985. {
  986. blast_scache16_page((unsigned long)page_address(page));
  987. }
  989. static void r4k_flush_page_to_ram_s32(struct page *page)
  990. {
  991. blast_scache32_page((unsigned long)page_address(page));
  992. }
  994. static void r4k_flush_page_to_ram_s64(struct page *page)
  995. {
  996. blast_scache64_page((unsigned long)page_address(page));
  997. }
  999. static void r4k_flush_page_to_ram_s128(struct page *page)
  1000. {
  1001. blast_scache128_page((unsigned long)page_address(page));
  1002. }
  1004. static void r4k_flush_page_to_ram_d16(struct page *page)
  1005. {
  1006. blast_dcache16_page((unsigned long)page_address(page));
  1007. }
  1009. static void r4k_flush_page_to_ram_d32(struct page *page)
  1010. {
  1011. blast_dcache32_page((unsigned long)page_address(page));
  1012. }
  1014. static void r4k_flush_page_to_ram_d32_r4600(struct page *page)
  1015. {
  1016. #ifdef R4600_V1_HIT_DCACHE_WAR
  1017. unsigned long flags;
  1019. __save_and_cli(flags);
  1020. __asm__ __volatile__("nop;nop;nop;nop");
  1021. #endif
  1022. blast_dcache32_page((unsigned long)page_address(page));
  1023. #ifdef R4600_V1_HIT_DCACHE_WAR
  1024. __restore_flags(flags);
  1025. #endif
  1026. }
  1028. static void
  1029. r4k_flush_icache_page_s(struct vm_area_struct *vma, struct page *page)
  1030. {
  1031. /*
  1032.  * We did an scache flush therefore PI is already clean.
  1033.  */
  1034. }
  1036. static void
  1037. r4k_flush_icache_range(unsigned long start, unsigned long end)
  1038. {
  1039. flush_cache_all();
  1040. }
  1042. /*
  1043.  * Ok, this seriously sucks.  We use them to flush a user page but don't
  1044.  * know the virtual address, so we have to blast away the whole icache
  1045.  * which is significantly more expensive than the real thing.
  1046.  */
  1047. static void
  1048. r4k_flush_icache_page_p(struct vm_area_struct *vma, struct page *page)
  1049. {
  1050. if (!(vma->vm_flags & VM_EXEC))
  1051. return;
  1053. flush_cache_all();
  1054. }
  1056. static void
  1057. r4k_dma_cache_wback_inv_pc(unsigned long addr, unsigned long size)
  1058. {
  1059. unsigned long end, a;
  1060. unsigned int flags;
  1062. if (size >= dcache_size) {
  1063. flush_cache_all();
  1064. } else {
  1065. #ifdef R4600_V2_HIT_CACHEOP_WAR
  1066. /* Workaround for R4600 bug.  See comment in <asm/war>. */
  1067. __save_and_cli(flags);
  1068. *(volatile unsigned long *)KSEG1;
  1069. #endif
  1071. a = addr & ~(dc_lsize - 1);
  1072. end = (addr + size) & ~(dc_lsize - 1);
  1073. while (1) {
  1074. flush_dcache_line(a); /* Hit_Writeback_Inv_D */
  1075. if (a == end) break;
  1076. a += dc_lsize;
  1077. }
  1078. #ifdef R4600_V2_HIT_CACHEOP_WAR
  1079. __restore_flags(flags);
  1080. #endif
  1081. }
  1082. bc_wback_inv(addr, size);
  1083. }
  1085. static void
  1086. r4k_dma_cache_wback_inv_sc(unsigned long addr, unsigned long size)
  1087. {
  1088. unsigned long end, a;
  1090. if (size >= scache_size) {
  1091. flush_cache_all();
  1092. return;
  1093. }
  1095. a = addr & ~(sc_lsize - 1);
  1096. end = (addr + size) & ~(sc_lsize - 1);
  1097. while (1) {
  1098. flush_scache_line(a); /* Hit_Writeback_Inv_SD */
  1099. if (a == end) break;
  1100. a += sc_lsize;
  1101. }
  1102. }
  1104. static void
  1105. r4k_dma_cache_inv_pc(unsigned long addr, unsigned long size)
  1106. {
  1107. unsigned long end, a;
  1108. unsigned int flags;
  1110. if (size >= dcache_size) {
  1111. flush_cache_all();
  1112. } else {
  1113. #ifdef R4600_V2_HIT_CACHEOP_WAR
  1114. /* Workaround for R4600 bug.  See comment above. */
  1115. __save_and_cli(flags);
  1116. *(volatile unsigned long *)KSEG1;
  1117. #endif
  1119. a = addr & ~(dc_lsize - 1);
  1120. end = (addr + size) & ~(dc_lsize - 1);
  1121. while (1) {
  1122. flush_dcache_line(a); /* Hit_Writeback_Inv_D */
  1123. if (a == end) break;
  1124. a += dc_lsize;
  1125. }
  1126. #ifdef R4600_V2_HIT_CACHEOP_WAR
  1127. __restore_flags(flags);
  1128. #endif
  1129. }
  1131. bc_inv(addr, size);
  1132. }
  1134. static void
  1135. r4k_dma_cache_inv_sc(unsigned long addr, unsigned long size)
  1136. {
  1137. unsigned long end, a;
  1139. if (size >= scache_size) {
  1140. flush_cache_all();
  1141. return;
  1142. }
  1144. a = addr & ~(sc_lsize - 1);
  1145. end = (addr + size) & ~(sc_lsize - 1);
  1146. while (1) {
  1147. flush_scache_line(a); /* Hit_Writeback_Inv_SD */
  1148. if (a == end) break;
  1149. a += sc_lsize;
  1150. }
  1151. }
  1153. /*
  1154.  * While we're protected against bad userland addresses we don't care
  1155.  * very much about what happens in that case.  Usually a segmentation
  1156.  * fault will dump the process later on anyway ...
  1157.  */
  1158. static void r4k_flush_cache_sigtramp(unsigned long addr)
  1159. {
  1160. #ifdef R4600_V1_HIT_DCACHE_WAR
  1161. unsigned long flags;
  1163. __save_and_cli(flags);
  1164. __asm__ __volatile__("nop;nop;nop;nop");
  1165. #endif
  1166. protected_writeback_dcache_line(addr & ~(dc_lsize - 1));
  1167. protected_flush_icache_line(addr & ~(ic_lsize - 1));
  1168. #ifdef R4600_V1_HIT_DCACHE_WAR
  1169. __restore_flags(flags);
  1170. #endif
  1171. }
  1173. static void r4600v20k_flush_cache_sigtramp(unsigned long addr)
  1174. {
  1175. unsigned int flags;
  1177. #ifdef R4600_V2_HIT_CACHEOP_WAR
  1178. __save_and_cli(flags);
  1180. /* Clear internal cache refill buffer */
  1181. *(volatile unsigned int *)KSEG1;
  1182. #endif
  1184. protected_writeback_dcache_line(addr & ~(dc_lsize - 1));
  1185. protected_flush_icache_line(addr & ~(ic_lsize - 1));
  1187. #ifdef R4600_V2_HIT_CACHEOP_WAR
  1188. __restore_flags(flags);
  1189. #endif
  1190. }
  1192. /* Detect and size the various r4k caches. */
  1193. static void __init probe_icache(unsigned long config)
  1194. {
  1195.         switch (mips_cpu.cputype) {
  1196.         case CPU_VR41XX:
  1197.         case CPU_VR4111:
  1198.         case CPU_VR4121:
  1199.         case CPU_VR4122:
  1200.         case CPU_VR4131:
  1201.         case CPU_VR4181:
  1202.         case CPU_VR4181A:
  1203.                 icache_size = 1 << (10 + ((config >> 9) & 7));
  1204.                 break;
  1205.         default:
  1206.                 icache_size = 1 << (12 + ((config >> 9) & 7));
  1207.                 break;
  1208.         }
  1209. ic_lsize = 16 << ((config >> 5) & 1);
  1211. printk("Primary instruction cache %dkb, linesize %d bytes.n",
  1212.        icache_size >> 10, ic_lsize);
  1213. }
  1215. static void __init probe_dcache(unsigned long config)
  1216. {
  1217.         switch (mips_cpu.cputype) {
  1218.         case CPU_VR41XX:
  1219.         case CPU_VR4111:
  1220.         case CPU_VR4121:
  1221.         case CPU_VR4122:
  1222.         case CPU_VR4131:
  1223.         case CPU_VR4181:
  1224.         case CPU_VR4181A:
  1225.                 dcache_size = 1 << (10 + ((config >> 6) & 7));
  1226.                 break;
  1227.         default:
  1228.                 dcache_size = 1 << (12 + ((config >> 6) & 7));
  1229.                 break;
  1230.         }
  1231. dc_lsize = 16 << ((config >> 4) & 1);
  1233. printk("Primary data cache %dkb, linesize %d bytes.n",
  1234.        dcache_size >> 10, dc_lsize);
  1235. }
  1238. /* If you even _breathe_ on this function, look at the gcc output
  1239.  * and make sure it does not pop things on and off the stack for
  1240.  * the cache sizing loop that executes in KSEG1 space or else
  1241.  * you will crash and burn badly.  You have been warned.
  1242.  */
  1243. static int __init probe_scache(unsigned long config)
  1244. {
  1245. extern unsigned long stext;
  1246. unsigned long flags, addr, begin, end, pow2;
  1247. int tmp;
  1249. tmp = ((config >> 17) & 1);
  1250. if(tmp)
  1251. return 0;
  1252. tmp = ((config >> 22) & 3);
  1253. switch(tmp) {
  1254. case 0:
  1255. sc_lsize = 16;
  1256. break;
  1257. case 1:
  1258. sc_lsize = 32;
  1259. break;
  1260. case 2:
  1261. sc_lsize = 64;
  1262. break;
  1263. case 3:
  1264. sc_lsize = 128;
  1265. break;
  1266. }
  1268. begin = (unsigned long) &stext;
  1269. begin &= ~((4 * 1024 * 1024) - 1);
  1270. end = begin + (4 * 1024 * 1024);
  1272. /* This is such a bitch, you'd think they would make it
  1273.  * easy to do this.  Away you daemons of stupidity!
  1274.  */
  1275. __save_and_cli(flags);
  1277. /* Fill each size-multiple cache line with a valid tag. */
  1278. pow2 = (64 * 1024);
  1279. for(addr = begin; addr < end; addr = (begin + pow2)) {
  1280. unsigned long *p = (unsigned long *) addr;
  1281. __asm__ __volatile__("nop" : : "r" (*p)); /* whee... */
  1282. pow2 <<= 1;
  1283. }
  1285. /* Load first line with zero (therefore invalid) tag. */
  1286. set_taglo(0);
  1287. set_taghi(0);
  1288. __asm__ __volatile__("nop; nop; nop; nop;"); /* avoid the hazard */
  1289. __asm__ __volatile__("nt.set noreordernt"
  1290.      ".set mips3nt"
  1291.      "cache 8, (%0)nt"
  1292.      ".set mips0nt"
  1293.      ".set reordernt" : : "r" (begin));
  1294. __asm__ __volatile__("nt.set noreordernt"
  1295.      ".set mips3nt"
  1296.      "cache 9, (%0)nt"
  1297.      ".set mips0nt"
  1298.      ".set reordernt" : : "r" (begin));
  1299. __asm__ __volatile__("nt.set noreordernt"
  1300.      ".set mips3nt"
  1301.      "cache 11, (%0)nt"
  1302.      ".set mips0nt"
  1303.      ".set reordernt" : : "r" (begin));
  1305. /* Now search for the wrap around point. */
  1306. pow2 = (128 * 1024);
  1307. tmp = 0;
  1308. for(addr = (begin + (128 * 1024)); addr < (end); addr = (begin + pow2)) {
  1309. __asm__ __volatile__("nt.set noreordernt"
  1310.      ".set mips3nt"
  1311.      "cache 7, (%0)nt"
  1312.      ".set mips0nt"
  1313.      ".set reordernt" : : "r" (addr));
  1314. __asm__ __volatile__("nop; nop; nop; nop;"); /* hazard... */
  1315. if(!get_taglo())
  1316. break;
  1317. pow2 <<= 1;
  1318. }
  1319. __restore_flags(flags);
  1320. addr -= begin;
  1321. printk("Secondary cache sized at %dK linesize %d bytes.n",
  1322.        (int) (addr >> 10), sc_lsize);
  1323. scache_size = addr;
  1324. return 1;
  1325. }
  1327. static void __init setup_noscache_funcs(void)
  1328. {
  1329. unsigned int prid;
  1331. switch(dc_lsize) {
  1332. case 16:
  1333. _clear_page = r4k_clear_page_d16;
  1334. _copy_page = r4k_copy_page_d16;
  1335. _flush_cache_all = r4k_flush_cache_all_d16i16;
  1336. _flush_cache_mm = r4k_flush_cache_mm_d16i16;
  1337. _flush_cache_range = r4k_flush_cache_range_d16i16;
  1338. _flush_cache_page = r4k_flush_cache_page_d16i16;
  1339. _flush_page_to_ram = r4k_flush_page_to_ram_d16;
  1340. break;
  1341. case 32:
  1342. prid = read_32bit_cp0_register(CP0_PRID) & 0xfff0;
  1343. if (prid == 0x2010) { /* R4600 V1.7 */
  1344. _clear_page = r4k_clear_page_r4600_v1;
  1345. _copy_page = r4k_copy_page_r4600_v1;
  1346. _flush_page_to_ram = r4k_flush_page_to_ram_d32_r4600;
  1347. } else if (prid == 0x2020) { /* R4600 V2.0 */
  1348. _clear_page = r4k_clear_page_r4600_v2;
  1349. _copy_page = r4k_copy_page_r4600_v2;
  1350. _flush_page_to_ram = r4k_flush_page_to_ram_d32;
  1351. } else {
  1352. _clear_page = r4k_clear_page_d32;
  1353. _copy_page = r4k_copy_page_d32;
  1354. _flush_page_to_ram = r4k_flush_page_to_ram_d32;
  1355. }
  1356. _flush_cache_all = r4k_flush_cache_all_d32i32;
  1357. _flush_cache_mm = r4k_flush_cache_mm_d32i32;
  1358. _flush_cache_range = r4k_flush_cache_range_d32i32;
  1359. _flush_cache_page = r4k_flush_cache_page_d32i32;
  1360. break;
  1361. }
  1362. ___flush_cache_all = _flush_cache_all;
  1364. _flush_icache_page = r4k_flush_icache_page_p;
  1366. _dma_cache_wback_inv = r4k_dma_cache_wback_inv_pc;
  1367. _dma_cache_wback = r4k_dma_cache_wback_inv_pc;
  1368. _dma_cache_inv = r4k_dma_cache_inv_pc;
  1369. }
  1371. static void __init setup_scache_funcs(void)
  1372. {
  1373. switch(sc_lsize) {
  1374. case 16:
  1375. switch(dc_lsize) {
  1376. case 16:
  1377. _flush_cache_all = r4k_flush_cache_all_s16d16i16;
  1378. _flush_cache_mm = r4k_flush_cache_mm_s16d16i16;
  1379. _flush_cache_range = r4k_flush_cache_range_s16d16i16;
  1380. _flush_cache_page = r4k_flush_cache_page_s16d16i16;
  1381. break;
  1382. case 32:
  1383. panic("Invalid cache configuration detected");
  1384. };
  1385. _flush_page_to_ram = r4k_flush_page_to_ram_s16;
  1386. _clear_page = r4k_clear_page_s16;
  1387. _copy_page = r4k_copy_page_s16;
  1388. break;
  1389. case 32:
  1390. switch(dc_lsize) {
  1391. case 16:
  1392. _flush_cache_all = r4k_flush_cache_all_s32d16i16;
  1393. _flush_cache_mm = r4k_flush_cache_mm_s32d16i16;
  1394. _flush_cache_range = r4k_flush_cache_range_s32d16i16;
  1395. _flush_cache_page = r4k_flush_cache_page_s32d16i16;
  1396. break;
  1397. case 32:
  1398. _flush_cache_all = r4k_flush_cache_all_s32d32i32;
  1399. _flush_cache_mm = r4k_flush_cache_mm_s32d32i32;
  1400. _flush_cache_range = r4k_flush_cache_range_s32d32i32;
  1401. _flush_cache_page = r4k_flush_cache_page_s32d32i32;
  1402. break;
  1403. };
  1404. _flush_page_to_ram = r4k_flush_page_to_ram_s32;
  1405. _clear_page = r4k_clear_page_s32;
  1406. _copy_page = r4k_copy_page_s32;
  1407. break;
  1408. case 64:
  1409. switch(dc_lsize) {
  1410. case 16:
  1411. _flush_cache_all = r4k_flush_cache_all_s64d16i16;
  1412. _flush_cache_mm = r4k_flush_cache_mm_s64d16i16;
  1413. _flush_cache_range = r4k_flush_cache_range_s64d16i16;
  1414. _flush_cache_page = r4k_flush_cache_page_s64d16i16;
  1415. break;
  1416. case 32:
  1417. _flush_cache_all = r4k_flush_cache_all_s64d32i32;
  1418. _flush_cache_mm = r4k_flush_cache_mm_s64d32i32;
  1419. _flush_cache_range = r4k_flush_cache_range_s64d32i32;
  1420. _flush_cache_page = r4k_flush_cache_page_s64d32i32;
  1421. break;
  1422. };
  1423. _flush_page_to_ram = r4k_flush_page_to_ram_s64;
  1424. _clear_page = r4k_clear_page_s64;
  1425. _copy_page = r4k_copy_page_s64;
  1426. break;
  1427. case 128:
  1428. switch(dc_lsize) {
  1429. case 16:
  1430. _flush_cache_all = r4k_flush_cache_all_s128d16i16;
  1431. _flush_cache_mm = r4k_flush_cache_mm_s128d16i16;
  1432. _flush_cache_range = r4k_flush_cache_range_s128d16i16;
  1433. _flush_cache_page = r4k_flush_cache_page_s128d16i16;
  1434. break;
  1435. case 32:
  1436. _flush_cache_all = r4k_flush_cache_all_s128d32i32;
  1437. _flush_cache_mm = r4k_flush_cache_mm_s128d32i32;
  1438. _flush_cache_range = r4k_flush_cache_range_s128d32i32;
  1439. _flush_cache_page = r4k_flush_cache_page_s128d32i32;
  1440. break;
  1441. };
  1442. _flush_page_to_ram = r4k_flush_page_to_ram_s128;
  1443. _clear_page = r4k_clear_page_s128;
  1444. _copy_page = r4k_copy_page_s128;
  1445. break;
  1446. }
  1447. ___flush_cache_all = _flush_cache_all;
  1448. _flush_icache_page = r4k_flush_icache_page_s;
  1449. _dma_cache_wback_inv = r4k_dma_cache_wback_inv_sc;
  1450. _dma_cache_wback = r4k_dma_cache_wback_inv_sc;
  1451. _dma_cache_inv = r4k_dma_cache_inv_sc;
  1452. }
  1454. typedef int (*probe_func_t)(unsigned long);
  1456. static inline void __init setup_scache(unsigned int config)
  1457. {
  1458. probe_func_t probe_scache_kseg1;
  1459. int sc_present = 0;
  1461. /* Maybe the cpu knows about a l2 cache? */
  1462. probe_scache_kseg1 = (probe_func_t) (KSEG1ADDR(&probe_scache));
  1463. sc_present = probe_scache_kseg1(config);
  1465. if (!sc_present) {
  1466. setup_noscache_funcs();
  1467. return;
  1468. }
  1470. switch(mips_cpu.cputype) {
  1471. case CPU_R5000:
  1472. case CPU_NEVADA:
  1473. setup_noscache_funcs();
  1474. #if defined(CONFIG_CPU_R5000) || defined(CONFIG_CPU_NEVADA)
  1475. r5k_sc_init();
  1476. #endif
  1477. break;
  1478. default:
  1479. setup_scache_funcs();
  1480. }
  1483. }
  1485. void __init ld_mmu_r4xx0(void)
  1486. {
  1487. unsigned long config = read_32bit_cp0_register(CP0_CONFIG);
  1489. change_cp0_config(CONF_CM_CMASK | CONF_CU, CONF_CM_DEFAULT);
  1491. probe_icache(config);
  1492. probe_dcache(config);
  1493. setup_scache(config);
  1495. switch(mips_cpu.cputype) {
  1496. case CPU_R4600: /* QED style two way caches? */
  1497. case CPU_R4700:
  1498. case CPU_R5000:
  1499. case CPU_NEVADA:
  1500. _flush_cache_page = r4k_flush_cache_page_d32i32_r4600;
  1501. }
  1503. _flush_cache_sigtramp = r4k_flush_cache_sigtramp;
  1504. _flush_icache_range = r4k_flush_icache_range; /* Ouch */
  1505. if ((read_32bit_cp0_register(CP0_PRID) & 0xfff0) == 0x2020) {
  1506. _flush_cache_sigtramp = r4600v20k_flush_cache_sigtramp;
  1507. }
  1509. __flush_cache_all();
  1510. }