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

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

嵌入式Linux

开发平台：

Unix_Linux

r4xx0.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/init.h>
  18. #include <linux/kernel.h>
  19. #include <linux/sched.h>
  20. #include <linux/mm.h>
  22. #include <asm/bootinfo.h>
  23. #include <asm/cpu.h>
  24. #include <asm/bcache.h>
  25. #include <asm/io.h>
  26. #include <asm/page.h>
  27. #include <asm/pgtable.h>
  28. #include <asm/system.h>
  29. #include <asm/mmu_context.h>
  31. /* CP0 hazard avoidance. */
  32. #define BARRIER __asm__ __volatile__(".set noreordernt" 
  33.      "nop; nop; nop; nop; nop; nop;nt" 
  34.      ".set reordernt")
  36. /* Primary cache parameters. */
  37. static int icache_size, dcache_size; /* Size in bytes */
  38. static int ic_lsize, dc_lsize;       /* LineSize in bytes */
  40. /* Secondary cache (if present) parameters. */
  41. static unsigned int scache_size, sc_lsize; /* Again, in bytes */
  43. #include <asm/cacheops.h>
  44. #include <asm/r4kcache.h>
  46. #undef DEBUG_CACHE
  48. /*
  49.  * Dummy cache handling routines for machines without boardcaches
  50.  */
  51. static void no_sc_noop(void) {}
  53. static struct bcache_ops no_sc_ops = {
  54. (void *)no_sc_noop, (void *)no_sc_noop,
  55. (void *)no_sc_noop, (void *)no_sc_noop
  56. };
  58. struct bcache_ops *bcops = &no_sc_ops;
  60. /*
  61.  * On processors with QED R4600 style two set assosicative cache
  62.  * this is the bit which selects the way in the cache for the
  63.  * indexed cachops.
  64.  */
  65. #define icache_waybit (icache_size >> 1)
  66. #define dcache_waybit (dcache_size >> 1)
  68. /*
  69.  * Zero an entire page.  Basically a simple unrolled loop should do the
  70.  * job but we want more performance by saving memory bus bandwidth.  We
  71.  * have five flavours of the routine available for:
  72.  *
  73.  * - 16byte cachelines and no second level cache
  74.  * - 32byte cachelines second level cache
  75.  * - a version which handles the buggy R4600 v1.x
  76.  * - a version which handles the buggy R4600 v2.0
  77.  * - Finally a last version without fancy cache games for the SC and MC
  78.  *   versions of R4000 and R4400.
  79.  */
  81. static void r4k_clear_page_d16(void * page)
  82. {
  83. __asm__ __volatile__(
  84. ".settnoreordernt"
  85. ".settnoatnt"
  86. ".settmips3nt"
  87. "daddiut$1,%0,%2n"
  88. "1:tcachet%3,(%0)nt"
  89. "sdt$0,(%0)nt"
  90. "sdt$0,8(%0)nt"
  91. "cachet%3,16(%0)nt"
  92. "sdt$0,16(%0)nt"
  93. "sdt$0,24(%0)nt"
  94. "daddiut%0,64nt"
  95. "cachet%3,-32(%0)nt"
  96. "sdt$0,-32(%0)nt"
  97. "sdt$0,-24(%0)nt"
  98. "cachet%3,-16(%0)nt"
  99. "sdt$0,-16(%0)nt"
  100. "bnet$1,%0,1bnt"
  101. "sdt$0,-8(%0)nt"
  102. ".settmips0nt"
  103. ".settatnt"
  104. ".settreorder"
  105. :"=r" (page)
  106. :"0" (page),
  107.  "I" (PAGE_SIZE),
  108.  "i" (Create_Dirty_Excl_D)
  109. :"$1","memory");
  110. }
  112. static void r4k_clear_page_d32(void * page)
  113. {
  114. __asm__ __volatile__(
  115. ".settnoreordernt"
  116. ".settnoatnt"
  117. ".settmips3nt"
  118. "daddiut$1,%0,%2n"
  119. "1:tcachet%3,(%0)nt"
  120. "sdt$0,(%0)nt"
  121. "sdt$0,8(%0)nt"
  122. "sdt$0,16(%0)nt"
  123. "sdt$0,24(%0)nt"
  124. "daddiut%0,64nt"
  125. "cachet%3,-32(%0)nt"
  126. "sdt$0,-32(%0)nt"
  127. "sdt$0,-24(%0)nt"
  128. "sdt$0,-16(%0)nt"
  129. "bnet$1,%0,1bnt"
  130. "sdt$0,-8(%0)nt"
  131. ".settmips0nt"
  132. ".settatnt"
  133. ".settreorder"
  134. :"=r" (page)
  135. :"0" (page),
  136.  "I" (PAGE_SIZE),
  137.  "i" (Create_Dirty_Excl_D)
  138. :"$1","memory");
  139. }
  142. /*
  143.  * This flavour of r4k_clear_page is for the R4600 V1.x.  Cite from the
  144.  * IDT R4600 V1.7 errata:
  145.  *
  146.  *  18. The CACHE instructions Hit_Writeback_Invalidate_D, Hit_Writeback_D,
  147.  *      Hit_Invalidate_D and Create_Dirty_Excl_D should only be
  148.  *      executed if there is no other dcache activity. If the dcache is
  149.  *      accessed for another instruction immeidately preceding when these
  150.  *      cache instructions are executing, it is possible that the dcache 
  151.  *      tag match outputs used by these cache instructions will be 
  152.  *      incorrect. These cache instructions should be preceded by at least
  153.  *      four instructions that are not any kind of load or store 
  154.  *      instruction.
  155.  *
  156.  *      This is not allowed:    lw
  157.  *                              nop
  158.  *                              nop
  159.  *                              nop
  160.  *                              cache       Hit_Writeback_Invalidate_D
  161.  *
  162.  *      This is allowed:        lw
  163.  *                              nop
  164.  *                              nop
  165.  *                              nop
  166.  *                              nop
  167.  *                              cache       Hit_Writeback_Invalidate_D
  168.  */
  169. static void r4k_clear_page_r4600_v1(void * page)
  170. {
  171. __asm__ __volatile__(
  172. ".settnoreordernt"
  173. ".settnoatnt"
  174. ".settmips3nt"
  175. "daddiut$1,%0,%2n"
  176. "1:tnopnt"
  177. "nopnt"
  178. "nopnt"
  179. "nopnt"
  180. "cachet%3,(%0)nt"
  181. "sdt$0,(%0)nt"
  182. "sdt$0,8(%0)nt"
  183. "sdt$0,16(%0)nt"
  184. "sdt$0,24(%0)nt"
  185. "daddiut%0,64nt"
  186. "nopnt"
  187. "nopnt"
  188. "nopnt"
  189. "cachet%3,-32(%0)nt"
  190. "sdt$0,-32(%0)nt"
  191. "sdt$0,-24(%0)nt"
  192. "sdt$0,-16(%0)nt"
  193. "bnet$1,%0,1bnt"
  194. "sdt$0,-8(%0)nt"
  195. ".settmips0nt"
  196. ".settatnt"
  197. ".settreorder"
  198. :"=r" (page)
  199. :"0" (page),
  200.  "I" (PAGE_SIZE),
  201.  "i" (Create_Dirty_Excl_D)
  202. :"$1","memory");
  203. }
  205. /*
  206.  * And this one is for the R4600 V2.0
  207.  */
  208. static void r4k_clear_page_r4600_v2(void * page)
  209. {
  210. unsigned int flags;
  212. __save_and_cli(flags);
  213. *(volatile unsigned int *)KSEG1;
  214. __asm__ __volatile__(
  215. ".settnoreordernt"
  216. ".settnoatnt"
  217. ".settmips3nt"
  218. "daddiut$1,%0,%2n"
  219. "1:tcachet%3,(%0)nt"
  220. "sdt$0,(%0)nt"
  221. "sdt$0,8(%0)nt"
  222. "sdt$0,16(%0)nt"
  223. "sdt$0,24(%0)nt"
  224. "daddiut%0,64nt"
  225. "cachet%3,-32(%0)nt"
  226. "sdt$0,-32(%0)nt"
  227. "sdt$0,-24(%0)nt"
  228. "sdt$0,-16(%0)nt"
  229. "bnet$1,%0,1bnt"
  230. "sdt$0,-8(%0)nt"
  231. ".settmips0nt"
  232. ".settatnt"
  233. ".settreorder"
  234. :"=r" (page)
  235. :"0" (page),
  236.  "I" (PAGE_SIZE),
  237.  "i" (Create_Dirty_Excl_D)
  238. :"$1","memory");
  239. __restore_flags(flags);
  240. }
  242. /*
  243.  * The next 4 versions are optimized for all possible scache configurations
  244.  * of the SC / MC versions of R4000 and R4400 ...
  245.  *
  246.  * Todo: For even better performance we should have a routine optimized for
  247.  * every legal combination of dcache / scache linesize.  When I (Ralf) tried
  248.  * this the kernel crashed shortly after mounting the root filesystem.  CPU
  249.  * bug?  Weirdo cache instruction semantics?
  250.  */
  251. static void r4k_clear_page_s16(void * page)
  252. {
  253. __asm__ __volatile__(
  254. ".settnoreordernt"
  255. ".settnoatnt"
  256. ".settmips3nt"
  257. "daddiut$1,%0,%2n"
  258. "1:tcachet%3,(%0)nt"
  259. "sdt$0,(%0)nt"
  260. "sdt$0,8(%0)nt"
  261. "cachet%3,16(%0)nt"
  262. "sdt$0,16(%0)nt"
  263. "sdt$0,24(%0)nt"
  264. "daddiut%0,64nt"
  265. "cachet%3,-32(%0)nt"
  266. "sdt$0,-32(%0)nt"
  267. "sdt$0,-24(%0)nt"
  268. "cachet%3,-16(%0)nt"
  269. "sdt$0,-16(%0)nt"
  270. "bnet$1,%0,1bnt"
  271. "sdt$0,-8(%0)nt"
  272. ".settmips0nt"
  273. ".settatnt"
  274. ".settreorder"
  275. :"=r" (page)
  276. :"0" (page),
  277.  "I" (PAGE_SIZE),
  278.  "i" (Create_Dirty_Excl_SD)
  279. :"$1","memory");
  280. }
  282. static void r4k_clear_page_s32(void * page)
  283. {
  284. __asm__ __volatile__(
  285. ".settnoreordernt"
  286. ".settnoatnt"
  287. ".settmips3nt"
  288. "daddiut$1,%0,%2n"
  289. "1:tcachet%3,(%0)nt"
  290. "sdt$0,(%0)nt"
  291. "sdt$0,8(%0)nt"
  292. "sdt$0,16(%0)nt"
  293. "sdt$0,24(%0)nt"
  294. "daddiut%0,64nt"
  295. "cachet%3,-32(%0)nt"
  296. "sdt$0,-32(%0)nt"
  297. "sdt$0,-24(%0)nt"
  298. "sdt$0,-16(%0)nt"
  299. "bnet$1,%0,1bnt"
  300. "sdt$0,-8(%0)nt"
  301. ".settmips0nt"
  302. ".settatnt"
  303. ".settreorder"
  304. :"=r" (page)
  305. :"0" (page),
  306.  "I" (PAGE_SIZE),
  307.  "i" (Create_Dirty_Excl_SD)
  308. :"$1","memory");
  309. }
  311. static void r4k_clear_page_s64(void * page)
  312. {
  313. __asm__ __volatile__(
  314. ".settnoreordernt"
  315. ".settnoatnt"
  316. ".settmips3nt"
  317. "daddiut$1,%0,%2n"
  318. "1:tcachet%3,(%0)nt"
  319. "sdt$0,(%0)nt"
  320. "sdt$0,8(%0)nt"
  321. "sdt$0,16(%0)nt"
  322. "sdt$0,24(%0)nt"
  323. "daddiut%0,64nt"
  324. "sdt$0,-32(%0)nt"
  325. "sdt$0,-24(%0)nt"
  326. "sdt$0,-16(%0)nt"
  327. "bnet$1,%0,1bnt"
  328. "sdt$0,-8(%0)nt"
  329. ".settmips0nt"
  330. ".settatnt"
  331. ".settreorder"
  332. :"=r" (page)
  333. :"0" (page),
  334.  "I" (PAGE_SIZE),
  335.  "i" (Create_Dirty_Excl_SD)
  336. :"$1","memory");
  337. }
  339. static void r4k_clear_page_s128(void * page)
  340. {
  341. __asm__ __volatile__(
  342. ".settnoreordernt"
  343. ".settnoatnt"
  344. ".settmips3nt"
  345. "daddiut$1,%0,%2n"
  346. "1:tcachet%3,(%0)nt"
  347. "sdt$0,(%0)nt"
  348. "sdt$0,8(%0)nt"
  349. "sdt$0,16(%0)nt"
  350. "sdt$0,24(%0)nt"
  351. "sdt$0,32(%0)nt"
  352. "sdt$0,40(%0)nt"
  353. "sdt$0,48(%0)nt"
  354. "sdt$0,56(%0)nt"
  355. "daddiut%0,128nt"
  356. "sdt$0,-64(%0)nt"
  357. "sdt$0,-56(%0)nt"
  358. "sdt$0,-48(%0)nt"
  359. "sdt$0,-40(%0)nt"
  360. "sdt$0,-32(%0)nt"
  361. "sdt$0,-24(%0)nt"
  362. "sdt$0,-16(%0)nt"
  363. "bnet$1,%0,1bnt"
  364. "sdt$0,-8(%0)nt"
  365. ".settmips0nt"
  366. ".settatnt"
  367. ".settreorder"
  368. :"=r" (page)
  369. :"0" (page),
  370.  "I" (PAGE_SIZE),
  371.  "i" (Create_Dirty_Excl_SD)
  372. :"$1","memory");
  373. }
  376. /*
  377.  * This is still inefficient.  We only can do better if we know the
  378.  * virtual address where the copy will be accessed.
  379.  */
  381. static void r4k_copy_page_d16(void * to, void * from)
  382. {
  383. unsigned long dummy1, dummy2;
  384. unsigned long reg1, reg2, reg3, reg4;
  386. __asm__ __volatile__(
  387. ".settnoreordernt"
  388. ".settnoatnt"
  389. ".settmips3nt"
  390. "daddiut$1,%0,%8n"
  391. "1:tcachet%9,(%0)nt"
  392. "lwt%2,(%1)nt"
  393. "lwt%3,4(%1)nt"
  394. "lwt%4,8(%1)nt"
  395. "lwt%5,12(%1)nt"
  396. "swt%2,(%0)nt"
  397. "swt%3,4(%0)nt"
  398. "swt%4,8(%0)nt"
  399. "swt%5,12(%0)nt"
  400. "cachet%9,16(%0)nt"
  401. "lwt%2,16(%1)nt"
  402. "lwt%3,20(%1)nt"
  403. "lwt%4,24(%1)nt"
  404. "lwt%5,28(%1)nt"
  405. "swt%2,16(%0)nt"
  406. "swt%3,20(%0)nt"
  407. "swt%4,24(%0)nt"
  408. "swt%5,28(%0)nt"
  409. "cachet%9,32(%0)nt"
  410. "daddiut%0,64nt"
  411. "daddiut%1,64nt"
  412. "lwt%2,-32(%1)nt"
  413. "lwt%3,-28(%1)nt"
  414. "lwt%4,-24(%1)nt"
  415. "lwt%5,-20(%1)nt"
  416. "swt%2,-32(%0)nt"
  417. "swt%3,-28(%0)nt"
  418. "swt%4,-24(%0)nt"
  419. "swt%5,-20(%0)nt"
  420. "cachet%9,-16(%0)nt"
  421. "lwt%2,-16(%1)nt"
  422. "lwt%3,-12(%1)nt"
  423. "lwt%4,-8(%1)nt"
  424. "lwt%5,-4(%1)nt"
  425. "swt%2,-16(%0)nt"
  426. "swt%3,-12(%0)nt"
  427. "swt%4,-8(%0)nt"
  428. "bnet$1,%0,1bnt"
  429. "swt%5,-4(%0)nt"
  430. ".settmips0nt"
  431. ".settatnt"
  432. ".settreorder"
  433. :"=r" (dummy1), "=r" (dummy2),
  434.  "=&r" (reg1), "=&r" (reg2), "=&r" (reg3), "=&r" (reg4)
  435. :"0" (to), "1" (from),
  436.  "I" (PAGE_SIZE),
  437.  "i" (Create_Dirty_Excl_D));
  438. }
  440. static void r4k_copy_page_d32(void * to, void * from)
  441. {
  442. unsigned long dummy1, dummy2;
  443. unsigned long reg1, reg2, reg3, reg4;
  445. __asm__ __volatile__(
  446. ".settnoreordernt"
  447. ".settnoatnt"
  448. ".settmips3nt"
  449. "daddiut$1,%0,%8n"
  450. "1:tcachet%9,(%0)nt"
  451. "lwt%2,(%1)nt"
  452. "lwt%3,4(%1)nt"
  453. "lwt%4,8(%1)nt"
  454. "lwt%5,12(%1)nt"
  455. "swt%2,(%0)nt"
  456. "swt%3,4(%0)nt"
  457. "swt%4,8(%0)nt"
  458. "swt%5,12(%0)nt"
  459. "lwt%2,16(%1)nt"
  460. "lwt%3,20(%1)nt"
  461. "lwt%4,24(%1)nt"
  462. "lwt%5,28(%1)nt"
  463. "swt%2,16(%0)nt"
  464. "swt%3,20(%0)nt"
  465. "swt%4,24(%0)nt"
  466. "swt%5,28(%0)nt"
  467. "cachet%9,32(%0)nt"
  468. "daddiut%0,64nt"
  469. "daddiut%1,64nt"
  470. "lwt%2,-32(%1)nt"
  471. "lwt%3,-28(%1)nt"
  472. "lwt%4,-24(%1)nt"
  473. "lwt%5,-20(%1)nt"
  474. "swt%2,-32(%0)nt"
  475. "swt%3,-28(%0)nt"
  476. "swt%4,-24(%0)nt"
  477. "swt%5,-20(%0)nt"
  478. "lwt%2,-16(%1)nt"
  479. "lwt%3,-12(%1)nt"
  480. "lwt%4,-8(%1)nt"
  481. "lwt%5,-4(%1)nt"
  482. "swt%2,-16(%0)nt"
  483. "swt%3,-12(%0)nt"
  484. "swt%4,-8(%0)nt"
  485. "bnet$1,%0,1bnt"
  486. "swt%5,-4(%0)nt"
  487. ".settmips0nt"
  488. ".settatnt"
  489. ".settreorder"
  490. :"=r" (dummy1), "=r" (dummy2),
  491.  "=&r" (reg1), "=&r" (reg2), "=&r" (reg3), "=&r" (reg4)
  492. :"0" (to), "1" (from),
  493.  "I" (PAGE_SIZE),
  494.  "i" (Create_Dirty_Excl_D));
  495. }
  497. /*
  498.  * Again a special version for the R4600 V1.x
  499.  */
  500. static void r4k_copy_page_r4600_v1(void * to, void * from)
  501. {
  502. unsigned long dummy1, dummy2;
  503. unsigned long reg1, reg2, reg3, reg4;
  505. __asm__ __volatile__(
  506. ".settnoreordernt"
  507. ".settnoatnt"
  508. ".settmips3nt"
  509. "daddiut$1,%0,%8n"
  510. "1:tnopnt"
  511. "nopnt"
  512. "nopnt"
  513. "nopnt"
  514. "tcachet%9,(%0)nt"
  515. "lwt%2,(%1)nt"
  516. "lwt%3,4(%1)nt"
  517. "lwt%4,8(%1)nt"
  518. "lwt%5,12(%1)nt"
  519. "swt%2,(%0)nt"
  520. "swt%3,4(%0)nt"
  521. "swt%4,8(%0)nt"
  522. "swt%5,12(%0)nt"
  523. "lwt%2,16(%1)nt"
  524. "lwt%3,20(%1)nt"
  525. "lwt%4,24(%1)nt"
  526. "lwt%5,28(%1)nt"
  527. "swt%2,16(%0)nt"
  528. "swt%3,20(%0)nt"
  529. "swt%4,24(%0)nt"
  530. "swt%5,28(%0)nt"
  531. "nopnt"
  532. "nopnt"
  533. "nopnt"
  534. "nopnt"
  535. "cachet%9,32(%0)nt"
  536. "daddiut%0,64nt"
  537. "daddiut%1,64nt"
  538. "lwt%2,-32(%1)nt"
  539. "lwt%3,-28(%1)nt"
  540. "lwt%4,-24(%1)nt"
  541. "lwt%5,-20(%1)nt"
  542. "swt%2,-32(%0)nt"
  543. "swt%3,-28(%0)nt"
  544. "swt%4,-24(%0)nt"
  545. "swt%5,-20(%0)nt"
  546. "lwt%2,-16(%1)nt"
  547. "lwt%3,-12(%1)nt"
  548. "lwt%4,-8(%1)nt"
  549. "lwt%5,-4(%1)nt"
  550. "swt%2,-16(%0)nt"
  551. "swt%3,-12(%0)nt"
  552. "swt%4,-8(%0)nt"
  553. "bnet$1,%0,1bnt"
  554. "swt%5,-4(%0)nt"
  555. ".settmips0nt"
  556. ".settatnt"
  557. ".settreorder"
  558. :"=r" (dummy1), "=r" (dummy2),
  559.  "=&r" (reg1), "=&r" (reg2), "=&r" (reg3), "=&r" (reg4)
  560. :"0" (to), "1" (from),
  561.  "I" (PAGE_SIZE),
  562.  "i" (Create_Dirty_Excl_D));
  563. }
  565. static void r4k_copy_page_r4600_v2(void * to, void * from)
  566. {
  567. unsigned long dummy1, dummy2;
  568. unsigned long reg1, reg2, reg3, reg4;
  569. unsigned int flags;
  571. __save_and_cli(flags);
  572. __asm__ __volatile__(
  573. ".settnoreordernt"
  574. ".settnoatnt"
  575. ".settmips3nt"
  576. "daddiut$1,%0,%8n"
  577. "1:tnopnt"
  578. "nopnt"
  579. "nopnt"
  580. "nopnt"
  581. "tcachet%9,(%0)nt"
  582. "lwt%2,(%1)nt"
  583. "lwt%3,4(%1)nt"
  584. "lwt%4,8(%1)nt"
  585. "lwt%5,12(%1)nt"
  586. "swt%2,(%0)nt"
  587. "swt%3,4(%0)nt"
  588. "swt%4,8(%0)nt"
  589. "swt%5,12(%0)nt"
  590. "lwt%2,16(%1)nt"
  591. "lwt%3,20(%1)nt"
  592. "lwt%4,24(%1)nt"
  593. "lwt%5,28(%1)nt"
  594. "swt%2,16(%0)nt"
  595. "swt%3,20(%0)nt"
  596. "swt%4,24(%0)nt"
  597. "swt%5,28(%0)nt"
  598. "nopnt"
  599. "nopnt"
  600. "nopnt"
  601. "nopnt"
  602. "cachet%9,32(%0)nt"
  603. "daddiut%0,64nt"
  604. "daddiut%1,64nt"
  605. "lwt%2,-32(%1)nt"
  606. "lwt%3,-28(%1)nt"
  607. "lwt%4,-24(%1)nt"
  608. "lwt%5,-20(%1)nt"
  609. "swt%2,-32(%0)nt"
  610. "swt%3,-28(%0)nt"
  611. "swt%4,-24(%0)nt"
  612. "swt%5,-20(%0)nt"
  613. "lwt%2,-16(%1)nt"
  614. "lwt%3,-12(%1)nt"
  615. "lwt%4,-8(%1)nt"
  616. "lwt%5,-4(%1)nt"
  617. "swt%2,-16(%0)nt"
  618. "swt%3,-12(%0)nt"
  619. "swt%4,-8(%0)nt"
  620. "bnet$1,%0,1bnt"
  621. "swt%5,-4(%0)nt"
  622. ".settmips0nt"
  623. ".settatnt"
  624. ".settreorder"
  625. :"=r" (dummy1), "=r" (dummy2),
  626.  "=&r" (reg1), "=&r" (reg2), "=&r" (reg3), "=&r" (reg4)
  627. :"0" (to), "1" (from),
  628.  "I" (PAGE_SIZE),
  629.  "i" (Create_Dirty_Excl_D));
  630. __restore_flags(flags);
  631. }
  633. /*
  634.  * These are for R4000SC / R4400MC
  635.  */
  636. static void r4k_copy_page_s16(void * to, void * from)
  637. {
  638. unsigned long dummy1, dummy2;
  639. unsigned long reg1, reg2, reg3, reg4;
  641. __asm__ __volatile__(
  642. ".settnoreordernt"
  643. ".settnoatnt"
  644. ".settmips3nt"
  645. "daddiut$1,%0,%8n"
  646. "1:tcachet%9,(%0)nt"
  647. "lwt%2,(%1)nt"
  648. "lwt%3,4(%1)nt"
  649. "lwt%4,8(%1)nt"
  650. "lwt%5,12(%1)nt"
  651. "swt%2,(%0)nt"
  652. "swt%3,4(%0)nt"
  653. "swt%4,8(%0)nt"
  654. "swt%5,12(%0)nt"
  655. "cachet%9,16(%0)nt"
  656. "lwt%2,16(%1)nt"
  657. "lwt%3,20(%1)nt"
  658. "lwt%4,24(%1)nt"
  659. "lwt%5,28(%1)nt"
  660. "swt%2,16(%0)nt"
  661. "swt%3,20(%0)nt"
  662. "swt%4,24(%0)nt"
  663. "swt%5,28(%0)nt"
  664. "cachet%9,32(%0)nt"
  665. "daddiut%0,64nt"
  666. "daddiut%1,64nt"
  667. "lwt%2,-32(%1)nt"
  668. "lwt%3,-28(%1)nt"
  669. "lwt%4,-24(%1)nt"
  670. "lwt%5,-20(%1)nt"
  671. "swt%2,-32(%0)nt"
  672. "swt%3,-28(%0)nt"
  673. "swt%4,-24(%0)nt"
  674. "swt%5,-20(%0)nt"
  675. "cachet%9,-16(%0)nt"
  676. "lwt%2,-16(%1)nt"
  677. "lwt%3,-12(%1)nt"
  678. "lwt%4,-8(%1)nt"
  679. "lwt%5,-4(%1)nt"
  680. "swt%2,-16(%0)nt"
  681. "swt%3,-12(%0)nt"
  682. "swt%4,-8(%0)nt"
  683. "bnet$1,%0,1bnt"
  684. "swt%5,-4(%0)nt"
  685. ".settmips0nt"
  686. ".settatnt"
  687. ".settreorder"
  688. :"=r" (dummy1), "=r" (dummy2),
  689.  "=&r" (reg1), "=&r" (reg2), "=&r" (reg3), "=&r" (reg4)
  690. :"0" (to), "1" (from),
  691.  "I" (PAGE_SIZE),
  692.  "i" (Create_Dirty_Excl_SD));
  693. }
  695. static void r4k_copy_page_s32(void * to, void * from)
  696. {
  697. unsigned long dummy1, dummy2;
  698. unsigned long reg1, reg2, reg3, reg4;
  700. __asm__ __volatile__(
  701. ".settnoreordernt"
  702. ".settnoatnt"
  703. ".settmips3nt"
  704. "daddiut$1,%0,%8n"
  705. "1:tcachet%9,(%0)nt"
  706. "lwt%2,(%1)nt"
  707. "lwt%3,4(%1)nt"
  708. "lwt%4,8(%1)nt"
  709. "lwt%5,12(%1)nt"
  710. "swt%2,(%0)nt"
  711. "swt%3,4(%0)nt"
  712. "swt%4,8(%0)nt"
  713. "swt%5,12(%0)nt"
  714. "lwt%2,16(%1)nt"
  715. "lwt%3,20(%1)nt"
  716. "lwt%4,24(%1)nt"
  717. "lwt%5,28(%1)nt"
  718. "swt%2,16(%0)nt"
  719. "swt%3,20(%0)nt"
  720. "swt%4,24(%0)nt"
  721. "swt%5,28(%0)nt"
  722. "cachet%9,32(%0)nt"
  723. "daddiut%0,64nt"
  724. "daddiut%1,64nt"
  725. "lwt%2,-32(%1)nt"
  726. "lwt%3,-28(%1)nt"
  727. "lwt%4,-24(%1)nt"
  728. "lwt%5,-20(%1)nt"
  729. "swt%2,-32(%0)nt"
  730. "swt%3,-28(%0)nt"
  731. "swt%4,-24(%0)nt"
  732. "swt%5,-20(%0)nt"
  733. "lwt%2,-16(%1)nt"
  734. "lwt%3,-12(%1)nt"
  735. "lwt%4,-8(%1)nt"
  736. "lwt%5,-4(%1)nt"
  737. "swt%2,-16(%0)nt"
  738. "swt%3,-12(%0)nt"
  739. "swt%4,-8(%0)nt"
  740. "bnet$1,%0,1bnt"
  741. "swt%5,-4(%0)nt"
  742. ".settmips0nt"
  743. ".settatnt"
  744. ".settreorder"
  745. :"=r" (dummy1), "=r" (dummy2),
  746.  "=&r" (reg1), "=&r" (reg2), "=&r" (reg3), "=&r" (reg4)
  747. :"0" (to), "1" (from),
  748.  "I" (PAGE_SIZE),
  749.  "i" (Create_Dirty_Excl_SD));
  750. }
  752. static void r4k_copy_page_s64(void * to, void * from)
  753. {
  754. unsigned long dummy1, dummy2;
  755. unsigned long reg1, reg2, reg3, reg4;
  757. __asm__ __volatile__(
  758. ".settnoreordernt"
  759. ".settnoatnt"
  760. ".settmips3nt"
  761. "daddiut$1,%0,%8n"
  762. "1:tcachet%9,(%0)nt"
  763. "lwt%2,(%1)nt"
  764. "lwt%3,4(%1)nt"
  765. "lwt%4,8(%1)nt"
  766. "lwt%5,12(%1)nt"
  767. "swt%2,(%0)nt"
  768. "swt%3,4(%0)nt"
  769. "swt%4,8(%0)nt"
  770. "swt%5,12(%0)nt"
  771. "lwt%2,16(%1)nt"
  772. "lwt%3,20(%1)nt"
  773. "lwt%4,24(%1)nt"
  774. "lwt%5,28(%1)nt"
  775. "swt%2,16(%0)nt"
  776. "swt%3,20(%0)nt"
  777. "swt%4,24(%0)nt"
  778. "swt%5,28(%0)nt"
  779. "daddiut%0,64nt"
  780. "daddiut%1,64nt"
  781. "lwt%2,-32(%1)nt"
  782. "lwt%3,-28(%1)nt"
  783. "lwt%4,-24(%1)nt"
  784. "lwt%5,-20(%1)nt"
  785. "swt%2,-32(%0)nt"
  786. "swt%3,-28(%0)nt"
  787. "swt%4,-24(%0)nt"
  788. "swt%5,-20(%0)nt"
  789. "lwt%2,-16(%1)nt"
  790. "lwt%3,-12(%1)nt"
  791. "lwt%4,-8(%1)nt"
  792. "lwt%5,-4(%1)nt"
  793. "swt%2,-16(%0)nt"
  794. "swt%3,-12(%0)nt"
  795. "swt%4,-8(%0)nt"
  796. "bnet$1,%0,1bnt"
  797. "swt%5,-4(%0)nt"
  798. ".settmips0nt"
  799. ".settatnt"
  800. ".settreorder"
  801. :"=r" (dummy1), "=r" (dummy2),
  802.  "=&r" (reg1), "=&r" (reg2), "=&r" (reg3), "=&r" (reg4)
  803. :"0" (to), "1" (from),
  804.  "I" (PAGE_SIZE),
  805.  "i" (Create_Dirty_Excl_SD));
  806. }
  808. static void r4k_copy_page_s128(void * to, void * from)
  809. {
  810. unsigned long dummy1, dummy2;
  811. unsigned long reg1, reg2, reg3, reg4;
  813. __asm__ __volatile__(
  814. ".settnoreordernt"
  815. ".settnoatnt"
  816. ".settmips3nt"
  817. "daddiut$1,%0,%8n"
  818. "1:tcachet%9,(%0)nt"
  819. "lwt%2,(%1)nt"
  820. "lwt%3,4(%1)nt"
  821. "lwt%4,8(%1)nt"
  822. "lwt%5,12(%1)nt"
  823. "swt%2,(%0)nt"
  824. "swt%3,4(%0)nt"
  825. "swt%4,8(%0)nt"
  826. "swt%5,12(%0)nt"
  827. "lwt%2,16(%1)nt"
  828. "lwt%3,20(%1)nt"
  829. "lwt%4,24(%1)nt"
  830. "lwt%5,28(%1)nt"
  831. "swt%2,16(%0)nt"
  832. "swt%3,20(%0)nt"
  833. "swt%4,24(%0)nt"
  834. "swt%5,28(%0)nt"
  835. "lwt%2,32(%1)nt"
  836. "lwt%3,36(%1)nt"
  837. "lwt%4,40(%1)nt"
  838. "lwt%5,44(%1)nt"
  839. "swt%2,32(%0)nt"
  840. "swt%3,36(%0)nt"
  841. "swt%4,40(%0)nt"
  842. "swt%5,44(%0)nt"
  843. "lwt%2,48(%1)nt"
  844. "lwt%3,52(%1)nt"
  845. "lwt%4,56(%1)nt"
  846. "lwt%5,60(%1)nt"
  847. "swt%2,48(%0)nt"
  848. "swt%3,52(%0)nt"
  849. "swt%4,56(%0)nt"
  850. "swt%5,60(%0)nt"
  851. "daddiut%0,128nt"
  852. "daddiut%1,128nt"
  853. "lwt%2,-64(%1)nt"
  854. "lwt%3,-60(%1)nt"
  855. "lwt%4,-56(%1)nt"
  856. "lwt%5,-52(%1)nt"
  857. "swt%2,-64(%0)nt"
  858. "swt%3,-60(%0)nt"
  859. "swt%4,-56(%0)nt"
  860. "swt%5,-52(%0)nt"
  861. "lwt%2,-48(%1)nt"
  862. "lwt%3,-44(%1)nt"
  863. "lwt%4,-40(%1)nt"
  864. "lwt%5,-36(%1)nt"
  865. "swt%2,-48(%0)nt"
  866. "swt%3,-44(%0)nt"
  867. "swt%4,-40(%0)nt"
  868. "swt%5,-36(%0)nt"
  869. "lwt%2,-32(%1)nt"
  870. "lwt%3,-28(%1)nt"
  871. "lwt%4,-24(%1)nt"
  872. "lwt%5,-20(%1)nt"
  873. "swt%2,-32(%0)nt"
  874. "swt%3,-28(%0)nt"
  875. "swt%4,-24(%0)nt"
  876. "swt%5,-20(%0)nt"
  877. "lwt%2,-16(%1)nt"
  878. "lwt%3,-12(%1)nt"
  879. "lwt%4,-8(%1)nt"
  880. "lwt%5,-4(%1)nt"
  881. "swt%2,-16(%0)nt"
  882. "swt%3,-12(%0)nt"
  883. "swt%4,-8(%0)nt"
  884. "bnet$1,%0,1bnt"
  885. "swt%5,-4(%0)nt"
  886. ".settmips0nt"
  887. ".settatnt"
  888. ".settreorder"
  889. :"=r" (dummy1), "=r" (dummy2),
  890.  "=&r" (reg1), "=&r" (reg2), "=&r" (reg3), "=&r" (reg4)
  891. :"0" (to), "1" (from),
  892.  "I" (PAGE_SIZE),
  893.  "i" (Create_Dirty_Excl_SD));
  894. }
  897. /*
  898.  * If you think for one second that this stuff coming up is a lot
  899.  * of bulky code eating too many kernel cache lines.  Think _again_.
  900.  *
  901.  * Consider:
  902.  * 1) Taken branches have a 3 cycle penalty on R4k
  903.  * 2) The branch itself is a real dead cycle on even R4600/R5000.
  904.  * 3) Only one of the following variants of each type is even used by
  905.  *    the kernel based upon the cache parameters we detect at boot time.
  906.  *
  907.  * QED.
  908.  */
  910. static inline void r4k_flush_cache_all_s16d16i16(void)
  911. {
  912. unsigned long flags;
  914. __save_and_cli(flags);
  915. blast_dcache16(); blast_icache16(); blast_scache16();
  916. __restore_flags(flags);
  917. }
  919. static inline void r4k_flush_cache_all_s32d16i16(void)
  920. {
  921. unsigned long flags;
  923. __save_and_cli(flags);
  924. blast_dcache16(); blast_icache16(); blast_scache32();
  925. __restore_flags(flags);
  926. }
  928. static inline void r4k_flush_cache_all_s64d16i16(void)
  929. {
  930. unsigned long flags;
  932. __save_and_cli(flags);
  933. blast_dcache16(); blast_icache16(); blast_scache64();
  934. __restore_flags(flags);
  935. }
  937. static inline void r4k_flush_cache_all_s128d16i16(void)
  938. {
  939. unsigned long flags;
  941. __save_and_cli(flags);
  942. blast_dcache16(); blast_icache16(); blast_scache128();
  943. __restore_flags(flags);
  944. }
  946. static inline void r4k_flush_cache_all_s32d32i32(void)
  947. {
  948. unsigned long flags;
  950. __save_and_cli(flags);
  951. blast_dcache32(); blast_icache32(); blast_scache32();
  952. __restore_flags(flags);
  953. }
  955. static inline void r4k_flush_cache_all_s64d32i32(void)
  956. {
  957. unsigned long flags;
  959. __save_and_cli(flags);
  960. blast_dcache32(); blast_icache32(); blast_scache64();
  961. __restore_flags(flags);
  962. }
  964. static inline void r4k_flush_cache_all_s128d32i32(void)
  965. {
  966. unsigned long flags;
  968. __save_and_cli(flags);
  969. blast_dcache32(); blast_icache32(); blast_scache128();
  970. __restore_flags(flags);
  971. }
  973. static inline void r4k_flush_cache_all_d16i16(void)
  974. {
  975. unsigned long flags;
  977. __save_and_cli(flags);
  978. blast_dcache16(); blast_icache16();
  979. __restore_flags(flags);
  980. }
  982. static inline void r4k_flush_cache_all_d32i32(void)
  983. {
  984. unsigned long flags;
  986. __save_and_cli(flags);
  987. blast_dcache32(); blast_icache32();
  988. __restore_flags(flags);
  989. }
  991. static void
  992. r4k_flush_cache_range_s16d16i16(struct mm_struct *mm,
  993.                                 unsigned long start,
  994.                                 unsigned long end)
  995. {
  996. struct vm_area_struct *vma;
  997. unsigned long flags;
  999. if (mm->context == 0)
  1000. return;
  1002. start &= PAGE_MASK;
  1003. #ifdef DEBUG_CACHE
  1004. printk("crange[%d,%08lx,%08lx]", (int)mm->context, start, end);
  1005. #endif
  1006. vma = find_vma(mm, start);
  1007. if (vma) {
  1008. if (mm->context != current->active_mm->context) {
  1009. r4k_flush_cache_all_s16d16i16();
  1010. } else {
  1011. pgd_t *pgd;
  1012. pmd_t *pmd;
  1013. pte_t *pte;
  1015. __save_and_cli(flags);
  1016. while(start < end) {
  1017. pgd = pgd_offset(mm, start);
  1018. pmd = pmd_offset(pgd, start);
  1019. pte = pte_offset(pmd, start);
  1021. if(pte_val(*pte) & _PAGE_VALID)
  1022. blast_scache16_page(start);
  1023. start += PAGE_SIZE;
  1024. }
  1025. __restore_flags(flags);
  1026. }
  1027. }
  1028. }
  1030. static void
  1031. r4k_flush_cache_range_s32d16i16(struct mm_struct *mm,
  1032.                                 unsigned long start,
  1033.                                 unsigned long end)
  1034. {
  1035. struct vm_area_struct *vma;
  1036. unsigned long flags;
  1038. if (mm->context == 0)
  1039. return;
  1041. start &= PAGE_MASK;
  1042. #ifdef DEBUG_CACHE
  1043. printk("crange[%d,%08lx,%08lx]", (int)mm->context, start, end);
  1044. #endif
  1045. vma = find_vma(mm, start);
  1046. if (vma) {
  1047. if (mm->context != current->active_mm->context) {
  1048. r4k_flush_cache_all_s32d16i16();
  1049. } else {
  1050. pgd_t *pgd;
  1051. pmd_t *pmd;
  1052. pte_t *pte;
  1054. __save_and_cli(flags);
  1055. while(start < end) {
  1056. pgd = pgd_offset(mm, start);
  1057. pmd = pmd_offset(pgd, start);
  1058. pte = pte_offset(pmd, start);
  1060. if(pte_val(*pte) & _PAGE_VALID)
  1061. blast_scache32_page(start);
  1062. start += PAGE_SIZE;
  1063. }
  1064. __restore_flags(flags);
  1065. }
  1066. }
  1067. }
  1069. static void r4k_flush_cache_range_s64d16i16(struct mm_struct *mm,
  1070.     unsigned long start,
  1071.     unsigned long end)
  1072. {
  1073. struct vm_area_struct *vma;
  1074. unsigned long flags;
  1076. if (mm->context == 0)
  1077. return;
  1079. start &= PAGE_MASK;
  1080. #ifdef DEBUG_CACHE
  1081. printk("crange[%d,%08lx,%08lx]", (int)mm->context, start, end);
  1082. #endif
  1083. vma = find_vma(mm, start);
  1084. if(vma) {
  1085. if (mm->context != current->active_mm->context) {
  1086. r4k_flush_cache_all_s64d16i16();
  1087. } else {
  1088. pgd_t *pgd;
  1089. pmd_t *pmd;
  1090. pte_t *pte;
  1092. __save_and_cli(flags);
  1093. while(start < end) {
  1094. pgd = pgd_offset(mm, start);
  1095. pmd = pmd_offset(pgd, start);
  1096. pte = pte_offset(pmd, start);
  1098. if(pte_val(*pte) & _PAGE_VALID)
  1099. blast_scache64_page(start);
  1100. start += PAGE_SIZE;
  1101. }
  1102. __restore_flags(flags);
  1103. }
  1104. }
  1105. }
  1107. static void r4k_flush_cache_range_s128d16i16(struct mm_struct *mm,
  1108.      unsigned long start,
  1109.      unsigned long end)
  1110. {
  1111. struct vm_area_struct *vma;
  1112. unsigned long flags;
  1114. if (mm->context == 0)
  1115. return;
  1117. start &= PAGE_MASK;
  1118. #ifdef DEBUG_CACHE
  1119. printk("crange[%d,%08lx,%08lx]", (int)mm->context, start, end);
  1120. #endif
  1121. vma = find_vma(mm, start);
  1122. if (vma) {
  1123. if (mm->context != current->active_mm->context) {
  1124. r4k_flush_cache_all_s128d16i16();
  1125. } else {
  1126. pgd_t *pgd;
  1127. pmd_t *pmd;
  1128. pte_t *pte;
  1130. __save_and_cli(flags);
  1131. while(start < end) {
  1132. pgd = pgd_offset(mm, start);
  1133. pmd = pmd_offset(pgd, start);
  1134. pte = pte_offset(pmd, start);
  1136. if(pte_val(*pte) & _PAGE_VALID)
  1137. blast_scache128_page(start);
  1138. start += PAGE_SIZE;
  1139. }
  1140. __restore_flags(flags);
  1141. }
  1142. }
  1143. }
  1145. static void r4k_flush_cache_range_s32d32i32(struct mm_struct *mm,
  1146.     unsigned long start,
  1147.     unsigned long end)
  1148. {
  1149. struct vm_area_struct *vma;
  1150. unsigned long flags;
  1152. if (mm->context == 0)
  1153. return;
  1155. start &= PAGE_MASK;
  1156. #ifdef DEBUG_CACHE
  1157. printk("crange[%d,%08lx,%08lx]", (int)mm->context, start, end);
  1158. #endif
  1159. vma = find_vma(mm, start);
  1160. if (vma) {
  1161. if (mm->context != current->active_mm->context) {
  1162. r4k_flush_cache_all_s32d32i32();
  1163. } else {
  1164. pgd_t *pgd;
  1165. pmd_t *pmd;
  1166. pte_t *pte;
  1168. __save_and_cli(flags);
  1169. while(start < end) {
  1170. pgd = pgd_offset(mm, start);
  1171. pmd = pmd_offset(pgd, start);
  1172. pte = pte_offset(pmd, start);
  1174. if(pte_val(*pte) & _PAGE_VALID)
  1175. blast_scache32_page(start);
  1176. start += PAGE_SIZE;
  1177. }
  1178. __restore_flags(flags);
  1179. }
  1180. }
  1181. }
  1183. static void r4k_flush_cache_range_s64d32i32(struct mm_struct *mm,
  1184.     unsigned long start,
  1185.     unsigned long end)
  1186. {
  1187. struct vm_area_struct *vma;
  1188. unsigned long flags;
  1190. if (mm->context == 0)
  1191. return;
  1193. start &= PAGE_MASK;
  1194. #ifdef DEBUG_CACHE
  1195. printk("crange[%d,%08lx,%08lx]", (int)mm->context, start, end);
  1196. #endif
  1197. vma = find_vma(mm, start);
  1198. if (vma) {
  1199. if (mm->context != current->active_mm->context) {
  1200. r4k_flush_cache_all_s64d32i32();
  1201. } else {
  1202. pgd_t *pgd;
  1203. pmd_t *pmd;
  1204. pte_t *pte;
  1206. __save_and_cli(flags);
  1207. while(start < end) {
  1208. pgd = pgd_offset(mm, start);
  1209. pmd = pmd_offset(pgd, start);
  1210. pte = pte_offset(pmd, start);
  1212. if(pte_val(*pte) & _PAGE_VALID)
  1213. blast_scache64_page(start);
  1214. start += PAGE_SIZE;
  1215. }
  1216. __restore_flags(flags);
  1217. }
  1218. }
  1219. }
  1221. static void r4k_flush_cache_range_s128d32i32(struct mm_struct *mm,
  1222.      unsigned long start,
  1223.      unsigned long end)
  1224. {
  1225. struct vm_area_struct *vma;
  1226. unsigned long flags;
  1228. if (mm->context == 0)
  1229. return;
  1231. start &= PAGE_MASK;
  1232. #ifdef DEBUG_CACHE
  1233. printk("crange[%d,%08lx,%08lx]", (int)mm->context, start, end);
  1234. #endif
  1235. vma = find_vma(mm, start);
  1236. if (vma) {
  1237. if (mm->context != current->active_mm->context) {
  1238. r4k_flush_cache_all_s128d32i32();
  1239. } else {
  1240. pgd_t *pgd;
  1241. pmd_t *pmd;
  1242. pte_t *pte;
  1244. __save_and_cli(flags);
  1245. while(start < end) {
  1246. pgd = pgd_offset(mm, start);
  1247. pmd = pmd_offset(pgd, start);
  1248. pte = pte_offset(pmd, start);
  1250. if(pte_val(*pte) & _PAGE_VALID)
  1251. blast_scache128_page(start);
  1252. start += PAGE_SIZE;
  1253. }
  1254. __restore_flags(flags);
  1255. }
  1256. }
  1257. }
  1259. static void r4k_flush_cache_range_d16i16(struct mm_struct *mm,
  1260.  unsigned long start,
  1261.  unsigned long end)
  1262. {
  1263. if (mm->context != 0) {
  1264. unsigned long flags;
  1266. #ifdef DEBUG_CACHE
  1267. printk("crange[%d,%08lx,%08lx]", (int)mm->context, start, end);
  1268. #endif
  1269. __save_and_cli(flags);
  1270. blast_dcache16(); blast_icache16();
  1271. __restore_flags(flags);
  1272. }
  1273. }
  1275. static void r4k_flush_cache_range_d32i32(struct mm_struct *mm,
  1276.  unsigned long start,
  1277.  unsigned long end)
  1278. {
  1279. if (mm->context != 0) {
  1280. unsigned long flags;
  1282. #ifdef DEBUG_CACHE
  1283. printk("crange[%d,%08lx,%08lx]", (int)mm->context, start, end);
  1284. #endif
  1285. __save_and_cli(flags);
  1286. blast_dcache32(); blast_icache32();
  1287. __restore_flags(flags);
  1288. }
  1289. }
  1291. /*
  1292.  * On architectures like the Sparc, we could get rid of lines in
  1293.  * the cache created only by a certain context, but on the MIPS
  1294.  * (and actually certain Sparc's) we cannot.
  1295.  */
  1296. static void r4k_flush_cache_mm_s16d16i16(struct mm_struct *mm)
  1297. {
  1298. if (mm->context != 0) {
  1299. #ifdef DEBUG_CACHE
  1300. printk("cmm[%d]", (int)mm->context);
  1301. #endif
  1302. r4k_flush_cache_all_s16d16i16();
  1303. }
  1304. }
  1306. static void r4k_flush_cache_mm_s32d16i16(struct mm_struct *mm)
  1307. {
  1308. if (mm->context != 0) {
  1309. #ifdef DEBUG_CACHE
  1310. printk("cmm[%d]", (int)mm->context);
  1311. #endif
  1312. r4k_flush_cache_all_s32d16i16();
  1313. }
  1314. }
  1316. static void r4k_flush_cache_mm_s64d16i16(struct mm_struct *mm)
  1317. {
  1318. if (mm->context != 0) {
  1319. #ifdef DEBUG_CACHE
  1320. printk("cmm[%d]", (int)mm->context);
  1321. #endif
  1322. r4k_flush_cache_all_s64d16i16();
  1323. }
  1324. }
  1326. static void r4k_flush_cache_mm_s128d16i16(struct mm_struct *mm)
  1327. {
  1328. if (mm->context != 0) {
  1329. #ifdef DEBUG_CACHE
  1330. printk("cmm[%d]", (int)mm->context);
  1331. #endif
  1332. r4k_flush_cache_all_s128d16i16();
  1333. }
  1334. }
  1336. static void r4k_flush_cache_mm_s32d32i32(struct mm_struct *mm)
  1337. {
  1338. if (mm->context != 0) {
  1339. #ifdef DEBUG_CACHE
  1340. printk("cmm[%d]", (int)mm->context);
  1341. #endif
  1342. r4k_flush_cache_all_s32d32i32();
  1343. }
  1344. }
  1346. static void r4k_flush_cache_mm_s64d32i32(struct mm_struct *mm)
  1347. {
  1348. if (mm->context != 0) {
  1349. #ifdef DEBUG_CACHE
  1350. printk("cmm[%d]", (int)mm->context);
  1351. #endif
  1352. r4k_flush_cache_all_s64d32i32();
  1353. }
  1354. }
  1356. static void r4k_flush_cache_mm_s128d32i32(struct mm_struct *mm)
  1357. {
  1358. if (mm->context != 0) {
  1359. #ifdef DEBUG_CACHE
  1360. printk("cmm[%d]", (int)mm->context);
  1361. #endif
  1362. r4k_flush_cache_all_s128d32i32();
  1363. }
  1364. }
  1366. static void r4k_flush_cache_mm_d16i16(struct mm_struct *mm)
  1367. {
  1368. if (mm->context != 0) {
  1369. #ifdef DEBUG_CACHE
  1370. printk("cmm[%d]", (int)mm->context);
  1371. #endif
  1372. r4k_flush_cache_all_d16i16();
  1373. }
  1374. }
  1376. static void r4k_flush_cache_mm_d32i32(struct mm_struct *mm)
  1377. {
  1378. if (mm->context != 0) {
  1379. #ifdef DEBUG_CACHE
  1380. printk("cmm[%d]", (int)mm->context);
  1381. #endif
  1382. r4k_flush_cache_all_d32i32();
  1383. }
  1384. }
  1386. static void r4k_flush_cache_page_s16d16i16(struct vm_area_struct *vma,
  1387.    unsigned long page)
  1388. {
  1389. struct mm_struct *mm = vma->vm_mm;
  1390. unsigned long flags;
  1391. pgd_t *pgdp;
  1392. pmd_t *pmdp;
  1393. pte_t *ptep;
  1395. /*
  1396.  * If ownes no valid ASID yet, cannot possibly have gotten
  1397.  * this page into the cache.
  1398.  */
  1399. if (mm->context == 0)
  1400. return;
  1402. #ifdef DEBUG_CACHE
  1403. printk("cpage[%d,%08lx]", (int)mm->context, page);
  1404. #endif
  1405. __save_and_cli(flags);
  1406. page &= PAGE_MASK;
  1407. pgdp = pgd_offset(mm, page);
  1408. pmdp = pmd_offset(pgdp, page);
  1409. ptep = pte_offset(pmdp, page);
  1411. /*
  1412.  * If the page isn't marked valid, the page cannot possibly be
  1413.  * in the cache.
  1414.  */
  1415. if (!(pte_val(*ptep) & _PAGE_VALID))
  1416. goto out;
  1418. /*
  1419.  * Doing flushes for another ASID than the current one is
  1420.  * too difficult since stupid R4k caches do a TLB translation
  1421.  * for every cache flush operation.  So we do indexed flushes
  1422.  * in that case, which doesn't overly flush the cache too much.
  1423.  */
  1424. if (mm->context != current->active_mm->context) {
  1425. /*
  1426.  * Do indexed flush, too much work to get the (possible)
  1427.  * tlb refills to work correctly.
  1428.  */
  1429. page = (KSEG0 + (page & (scache_size - 1)));
  1430. blast_dcache16_page_indexed(page);
  1431. blast_scache16_page_indexed(page);
  1432. } else
  1433. blast_scache16_page(page);
  1434. out:
  1435. __restore_flags(flags);
  1436. }
  1438. static void r4k_flush_cache_page_s32d16i16(struct vm_area_struct *vma,
  1439.    unsigned long page)
  1440. {
  1441. struct mm_struct *mm = vma->vm_mm;
  1442. unsigned long flags;
  1443. pgd_t *pgdp;
  1444. pmd_t *pmdp;
  1445. pte_t *ptep;
  1447. /*
  1448.  * If ownes no valid ASID yet, cannot possibly have gotten
  1449.  * this page into the cache.
  1450.  */
  1451. if (mm->context == 0)
  1452. return;
  1454. #ifdef DEBUG_CACHE
  1455. printk("cpage[%d,%08lx]", (int)mm->context, page);
  1456. #endif
  1457. __save_and_cli(flags);
  1458. page &= PAGE_MASK;
  1459. pgdp = pgd_offset(mm, page);
  1460. pmdp = pmd_offset(pgdp, page);
  1461. ptep = pte_offset(pmdp, page);
  1463. /* If the page isn't marked valid, the page cannot possibly be
  1464.  * in the cache.
  1465.  */
  1466. if (!(pte_val(*ptep) & _PAGE_VALID))
  1467. goto out;
  1469. /*
  1470.  * Doing flushes for another ASID than the current one is
  1471.  * too difficult since stupid R4k caches do a TLB translation
  1472.  * for every cache flush operation.  So we do indexed flushes
  1473.  * in that case, which doesn't overly flush the cache too much.
  1474.  */
  1475. if (mm->context != current->active_mm->context) {
  1476. /*
  1477.  * Do indexed flush, too much work to get the (possible)
  1478.  * tlb refills to work correctly.
  1479.  */
  1480. page = (KSEG0 + (page & (scache_size - 1)));
  1481. blast_dcache16_page_indexed(page);
  1482. blast_scache32_page_indexed(page);
  1483. } else
  1484. blast_scache32_page(page);
  1485. out:
  1486. __restore_flags(flags);
  1487. }
  1489. static void r4k_flush_cache_page_s64d16i16(struct vm_area_struct *vma,
  1490.    unsigned long page)
  1491. {
  1492. struct mm_struct *mm = vma->vm_mm;
  1493. unsigned long flags;
  1494. pgd_t *pgdp;
  1495. pmd_t *pmdp;
  1496. pte_t *ptep;
  1498. /*
  1499.  * If ownes no valid ASID yet, cannot possibly have gotten
  1500.  * this page into the cache.
  1501.  */
  1502. if (mm->context == 0)
  1503. return;
  1505. #ifdef DEBUG_CACHE
  1506. printk("cpage[%d,%08lx]", (int)mm->context, page);
  1507. #endif
  1508. __save_and_cli(flags);
  1509. page &= PAGE_MASK;
  1510. pgdp = pgd_offset(mm, page);
  1511. pmdp = pmd_offset(pgdp, page);
  1512. ptep = pte_offset(pmdp, page);
  1514. /* If the page isn't marked valid, the page cannot possibly be
  1515.  * in the cache.
  1516.  */
  1517. if (!(pte_val(*ptep) & _PAGE_VALID))
  1518. goto out;
  1520. /*
  1521.  * Doing flushes for another ASID than the current one is
  1522.  * too difficult since stupid R4k caches do a TLB translation
  1523.  * for every cache flush operation.  So we do indexed flushes
  1524.  * in that case, which doesn't overly flush the cache too much.
  1525.  */
  1526. if (mm->context != current->active_mm->context) {
  1527. /*
  1528.  * Do indexed flush, too much work to get the (possible)
  1529.  * tlb refills to work correctly.
  1530.  */
  1531. page = (KSEG0 + (page & (scache_size - 1)));
  1532. blast_dcache16_page_indexed(page);
  1533. blast_scache64_page_indexed(page);
  1534. } else
  1535. blast_scache64_page(page);
  1536. out:
  1537. __restore_flags(flags);
  1538. }
  1540. static void r4k_flush_cache_page_s128d16i16(struct vm_area_struct *vma,
  1541.     unsigned long page)
  1542. {
  1543. struct mm_struct *mm = vma->vm_mm;
  1544. unsigned long flags;
  1545. pgd_t *pgdp;
  1546. pmd_t *pmdp;
  1547. pte_t *ptep;
  1549. /*
  1550.  * If ownes no valid ASID yet, cannot possibly have gotten
  1551.  * this page into the cache.
  1552.  */
  1553. if (mm->context == 0)
  1554. return;
  1556. #ifdef DEBUG_CACHE
  1557. printk("cpage[%d,%08lx]", (int)mm->context, page);
  1558. #endif
  1559. __save_and_cli(flags);
  1560. page &= PAGE_MASK;
  1561. pgdp = pgd_offset(mm, page);
  1562. pmdp = pmd_offset(pgdp, page);
  1563. ptep = pte_offset(pmdp, page);
  1565. /*
  1566.  * If the page isn't marked valid, the page cannot possibly be
  1567.  * in the cache.
  1568.  */
  1569. if (!(pte_val(*ptep) & _PAGE_VALID))
  1570. goto out;
  1572. /*
  1573.  * Doing flushes for another ASID than the current one is
  1574.  * too difficult since stupid R4k caches do a TLB translation
  1575.  * for every cache flush operation.  So we do indexed flushes
  1576.  * in that case, which doesn't overly flush the cache too much.
  1577.  */
  1578. if (mm->context != current->active_mm->context) {
  1579. /*
  1580.  * Do indexed flush, too much work to get the (possible)
  1581.  * tlb refills to work correctly.
  1582.  */
  1583. page = (KSEG0 + (page & (scache_size - 1)));
  1584. blast_dcache16_page_indexed(page);
  1585. blast_scache128_page_indexed(page);
  1586. } else
  1587. blast_scache128_page(page);
  1588. out:
  1589. __restore_flags(flags);
  1590. }
  1592. static void r4k_flush_cache_page_s32d32i32(struct vm_area_struct *vma,
  1593.    unsigned long page)
  1594. {
  1595. struct mm_struct *mm = vma->vm_mm;
  1596. unsigned long flags;
  1597. pgd_t *pgdp;
  1598. pmd_t *pmdp;
  1599. pte_t *ptep;
  1601. /*
  1602.  * If ownes no valid ASID yet, cannot possibly have gotten
  1603.  * this page into the cache.
  1604.  */
  1605. if (mm->context == 0)
  1606. return;
  1608. #ifdef DEBUG_CACHE
  1609. printk("cpage[%d,%08lx]", (int)mm->context, page);
  1610. #endif
  1611. __save_and_cli(flags);
  1612. page &= PAGE_MASK;
  1613. pgdp = pgd_offset(mm, page);
  1614. pmdp = pmd_offset(pgdp, page);
  1615. ptep = pte_offset(pmdp, page);
  1617. /*
  1618.  * If the page isn't marked valid, the page cannot possibly be
  1619.  * in the cache.
  1620.  */
  1621. if (!(pte_val(*ptep) & _PAGE_VALID))
  1622. goto out;
  1624. /*
  1625.  * Doing flushes for another ASID than the current one is
  1626.  * too difficult since stupid R4k caches do a TLB translation
  1627.  * for every cache flush operation.  So we do indexed flushes
  1628.  * in that case, which doesn't overly flush the cache too much.
  1629.  */
  1630. if (mm->context != current->active_mm->context) {
  1631. /*
  1632.  * Do indexed flush, too much work to get the (possible)
  1633.  * tlb refills to work correctly.
  1634.  */
  1635. page = (KSEG0 + (page & (scache_size - 1)));
  1636. blast_dcache32_page_indexed(page);
  1637. blast_scache32_page_indexed(page);
  1638. } else
  1639. blast_scache32_page(page);
  1640. out:
  1641. __restore_flags(flags);
  1642. }
  1644. static void r4k_flush_cache_page_s64d32i32(struct vm_area_struct *vma,
  1645.    unsigned long page)
  1646. {
  1647. struct mm_struct *mm = vma->vm_mm;
  1648. unsigned long flags;
  1649. pgd_t *pgdp;
  1650. pmd_t *pmdp;
  1651. pte_t *ptep;
  1653. /*
  1654.  * If ownes no valid ASID yet, cannot possibly have gotten
  1655.  * this page into the cache.
  1656.  */
  1657. if (mm->context == 0)
  1658. return;
  1660. #ifdef DEBUG_CACHE
  1661. printk("cpage[%d,%08lx]", (int)mm->context, page);
  1662. #endif
  1663. __save_and_cli(flags);
  1664. page &= PAGE_MASK;
  1665. pgdp = pgd_offset(mm, page);
  1666. pmdp = pmd_offset(pgdp, page);
  1667. ptep = pte_offset(pmdp, page);
  1669. /*
  1670.  * If the page isn't marked valid, the page cannot possibly be
  1671.  * in the cache.
  1672.  */
  1673. if (!(pte_val(*ptep) & _PAGE_VALID))
  1674. goto out;
  1676. /*
  1677.  * Doing flushes for another ASID than the current one is
  1678.  * too difficult since stupid R4k caches do a TLB translation
  1679.  * for every cache flush operation.  So we do indexed flushes
  1680.  * in that case, which doesn't overly flush the cache too much.
  1681.  */
  1682. if (mm->context != current->active_mm->context) {
  1683. /*
  1684.  * Do indexed flush, too much work to get the (possible)
  1685.  * tlb refills to work correctly.
  1686.  */
  1687. page = (KSEG0 + (page & (scache_size - 1)));
  1688. blast_dcache32_page_indexed(page);
  1689. blast_scache64_page_indexed(page);
  1690. } else
  1691. blast_scache64_page(page);
  1692. out:
  1693. __restore_flags(flags);
  1694. }
  1696. static void r4k_flush_cache_page_s128d32i32(struct vm_area_struct *vma,
  1697.     unsigned long page)
  1698. {
  1699. struct mm_struct *mm = vma->vm_mm;
  1700. unsigned long flags;
  1701. pgd_t *pgdp;
  1702. pmd_t *pmdp;
  1703. pte_t *ptep;
  1705. /*
  1706.  * If ownes no valid ASID yet, cannot possibly have gotten
  1707.  * this page into the cache.
  1708.  */
  1709. if (mm->context == 0)
  1710. return;
  1712. #ifdef DEBUG_CACHE
  1713. printk("cpage[%d,%08lx]", (int)mm->context, page);
  1714. #endif
  1715. __save_and_cli(flags);
  1716. page &= PAGE_MASK;
  1717. pgdp = pgd_offset(mm, page);
  1718. pmdp = pmd_offset(pgdp, page);
  1719. ptep = pte_offset(pmdp, page);
  1721. /*
  1722.  * If the page isn't marked valid, the page cannot possibly be
  1723.  * in the cache.
  1724.  */
  1725. if (!(pte_val(*ptep) & _PAGE_VALID))
  1726. goto out;
  1728. /*
  1729.  * Doing flushes for another ASID than the current one is
  1730.  * too difficult since stupid R4k caches do a TLB translation
  1731.  * for every cache flush operation.  So we do indexed flushes
  1732.  * in that case, which doesn't overly flush the cache too much.
  1733.  */
  1734. if (mm->context != current->active_mm->context) {
  1735. /* Do indexed flush, too much work to get the (possible)
  1736.  * tlb refills to work correctly.
  1737.  */
  1738. page = (KSEG0 + (page & (scache_size - 1)));
  1739. blast_dcache32_page_indexed(page);
  1740. blast_scache128_page_indexed(page);
  1741. } else
  1742. blast_scache128_page(page);
  1743. out:
  1744. __restore_flags(flags);
  1745. }
  1747. static void r4k_flush_cache_page_d16i16(struct vm_area_struct *vma,
  1748. unsigned long page)
  1749. {
  1750. struct mm_struct *mm = vma->vm_mm;
  1751. unsigned long flags;
  1752. pgd_t *pgdp;
  1753. pmd_t *pmdp;
  1754. pte_t *ptep;
  1756. /*
  1757.  * If ownes no valid ASID yet, cannot possibly have gotten
  1758.  * this page into the cache.
  1759.  */
  1760. if (mm->context == 0)
  1761. return;
  1763. #ifdef DEBUG_CACHE
  1764. printk("cpage[%d,%08lx]", (int)mm->context, page);
  1765. #endif
  1766. __save_and_cli(flags);
  1767. page &= PAGE_MASK;
  1768. pgdp = pgd_offset(mm, page);
  1769. pmdp = pmd_offset(pgdp, page);
  1770. ptep = pte_offset(pmdp, page);
  1772. /*
  1773.  * If the page isn't marked valid, the page cannot possibly be
  1774.  * in the cache.
  1775.  */
  1776. if (!(pte_val(*ptep) & _PAGE_VALID))
  1777. goto out;
  1779. /*
  1780.  * Doing flushes for another ASID than the current one is
  1781.  * too difficult since stupid R4k caches do a TLB translation
  1782.  * for every cache flush operation.  So we do indexed flushes
  1783.  * in that case, which doesn't overly flush the cache too much.
  1784.  */
  1785. if (mm == current->active_mm) {
  1786. blast_dcache16_page(page);
  1787. } else {
  1788. /* Do indexed flush, too much work to get the (possible)
  1789.  * tlb refills to work correctly.
  1790.  */
  1791. page = (KSEG0 + (page & (dcache_size - 1)));
  1792. blast_dcache16_page_indexed(page);
  1793. }
  1794. out:
  1795. __restore_flags(flags);
  1796. }
  1798. static void r4k_flush_cache_page_d32i32(struct vm_area_struct *vma,
  1799. unsigned long page)
  1800. {
  1801. struct mm_struct *mm = vma->vm_mm;
  1802. unsigned long flags;
  1803. pgd_t *pgdp;
  1804. pmd_t *pmdp;
  1805. pte_t *ptep;
  1807. /*
  1808.  * If ownes no valid ASID yet, cannot possibly have gotten
  1809.  * this page into the cache.
  1810.  */
  1811. if (mm->context == 0)
  1812. return;
  1814. #ifdef DEBUG_CACHE
  1815. printk("cpage[%d,%08lx]", (int)mm->context, page);
  1816. #endif
  1817. __save_and_cli(flags);
  1818. page &= PAGE_MASK;
  1819. pgdp = pgd_offset(mm, page);
  1820. pmdp = pmd_offset(pgdp, page);
  1821. ptep = pte_offset(pmdp, page);
  1823. /*
  1824.  * If the page isn't marked valid, the page cannot possibly be
  1825.  * in the cache.
  1826.  */
  1827. if (!(pte_val(*ptep) & _PAGE_PRESENT))
  1828. goto out;
  1830. /*
  1831.  * Doing flushes for another ASID than the current one is
  1832.  * too difficult since stupid R4k caches do a TLB translation
  1833.  * for every cache flush operation.  So we do indexed flushes
  1834.  * in that case, which doesn't overly flush the cache too much.
  1835.  */
  1836. if ((mm == current->active_mm) && (pte_val(*ptep) & _PAGE_VALID)) {
  1837. blast_dcache32_page(page);
  1838. } else {
  1839. /*
  1840.  * Do indexed flush, too much work to get the (possible)
  1841.  * tlb refills to work correctly.
  1842.  */
  1843. page = (KSEG0 + (page & (dcache_size - 1)));
  1844. blast_dcache32_page_indexed(page);
  1845. }
  1846. out:
  1847. __restore_flags(flags);
  1848. }
  1850. static void r4k_flush_cache_page_d32i32_r4600(struct vm_area_struct *vma,
  1851.       unsigned long page)
  1852. {
  1853. struct mm_struct *mm = vma->vm_mm;
  1854. unsigned long flags;
  1855. pgd_t *pgdp;
  1856. pmd_t *pmdp;
  1857. pte_t *ptep;
  1859. /*
  1860.  * If ownes no valid ASID yet, cannot possibly have gotten
  1861.  * this page into the cache.
  1862.  */
  1863. if (mm->context == 0)
  1864. return;
  1866. #ifdef DEBUG_CACHE
  1867. printk("cpage[%d,%08lx]", (int)mm->context, page);
  1868. #endif
  1869. __save_and_cli(flags);
  1870. page &= PAGE_MASK;
  1871. pgdp = pgd_offset(mm, page);
  1872. pmdp = pmd_offset(pgdp, page);
  1873. ptep = pte_offset(pmdp, page);
  1875. /*
  1876.  * If the page isn't marked valid, the page cannot possibly be
  1877.  * in the cache.
  1878.  */
  1879. if (!(pte_val(*ptep) & _PAGE_PRESENT))
  1880. goto out;
  1882. /*
  1883.  * Doing flushes for another ASID than the current one is
  1884.  * too difficult since stupid R4k caches do a TLB translation
  1885.  * for every cache flush operation.  So we do indexed flushes
  1886.  * in that case, which doesn't overly flush the cache too much.
  1887.  */
  1888. if ((mm == current->active_mm) && (pte_val(*ptep) & _PAGE_VALID)) {
  1889. blast_dcache32_page(page);
  1890. } else {
  1891. /* Do indexed flush, too much work to get the (possible)
  1892.  * tlb refills to work correctly.
  1893.  */
  1894. page = (KSEG0 + (page & (dcache_size - 1)));
  1895. blast_dcache32_page_indexed(page);
  1896. blast_dcache32_page_indexed(page ^ dcache_waybit);
  1897. }
  1898. out:
  1899. __restore_flags(flags);
  1900. }
  1902. /* If the addresses passed to these routines are valid, they are
  1903.  * either:
  1904.  *
  1905.  * 1) In KSEG0, so we can do a direct flush of the page.
  1906.  * 2) In KSEG2, and since every process can translate those
  1907.  *    addresses all the time in kernel mode we can do a direct
  1908.  *    flush.
  1909.  * 3) In KSEG1, no flush necessary.
  1910.  */
  1911. static void r4k_flush_page_to_ram_s16(struct page *page)
  1912. {
  1913. blast_scache16_page((unsigned long)page_address(page));
  1914. }
  1916. static void r4k_flush_page_to_ram_s32(struct page *page)
  1917. {
  1918. blast_scache32_page((unsigned long)page_address(page));
  1919. }
  1921. static void r4k_flush_page_to_ram_s64(struct page *page)
  1922. {
  1923. blast_scache64_page((unsigned long)page_address(page));
  1924. }
  1926. static void r4k_flush_page_to_ram_s128(struct page *page)
  1927. {
  1928. blast_scache128_page((unsigned long)page_address(page));
  1929. }
  1931. static void r4k_flush_page_to_ram_d16(struct page *page)
  1932. {
  1933. blast_dcache16_page((unsigned long)page_address(page));
  1934. }
  1936. static void r4k_flush_page_to_ram_d32(struct page *page)
  1937. {
  1938. blast_dcache32_page((unsigned long)page_address(page));
  1939. }
  1941. static void r4k_flush_page_to_ram_d32_r4600(struct page *page)
  1942. {
  1943. unsigned long flags;
  1945. __save_and_cli(flags); /* For R4600 v1.7 bug.  */
  1946. blast_dcache32_page((unsigned long)page_address(page));
  1947. __restore_flags(flags);
  1948. }
  1950. static void
  1951. r4k_flush_icache_page_s(struct vm_area_struct *vma, struct page *page)
  1952. {
  1953. /*
  1954.  * We did an scache flush therefore PI is already clean.
  1955.  */
  1956. }
  1958. static void
  1959. r4k_flush_icache_range(unsigned long start, unsigned long end)
  1960. {
  1961. flush_cache_all();
  1962. }
  1964. /*
  1965.  * Ok, this seriously sucks.  We use them to flush a user page but don't
  1966.  * know the virtual address, so we have to blast away the whole icache
  1967.  * which is significantly more expensive than the real thing.
  1968.  */
  1969. static void
  1970. r4k_flush_icache_page_p(struct vm_area_struct *vma, struct page *page)
  1971. {
  1972. if (!(vma->vm_flags & VM_EXEC))
  1973. return;
  1975. flush_cache_all();
  1976. }
  1978. /*
  1979.  * Writeback and invalidate the primary cache dcache before DMA.
  1980.  *
  1981.  * R4600 v2.0 bug: "The CACHE instructions Hit_Writeback_Inv_D,
  1982.  * Hit_Writeback_D, Hit_Invalidate_D and Create_Dirty_Exclusive_D will only
  1983.  * operate correctly if the internal data cache refill buffer is empty.  These
  1984.  * CACHE instructions should be separated from any potential data cache miss
  1985.  * by a load instruction to an uncached address to empty the response buffer."
  1986.  * (Revision 2.0 device errata from IDT available on http://www.idt.com/
  1987.  * in .pdf format.)
  1988.  */
  1989. static void
  1990. r4k_dma_cache_wback_inv_pc(unsigned long addr, unsigned long size)
  1991. {
  1992. unsigned long end, a;
  1993. unsigned int flags;
  1995. if (size >= dcache_size) {
  1996. flush_cache_all();
  1997. } else {
  1998. /* Workaround for R4600 bug.  See comment above. */
  1999. __save_and_cli(flags);
  2000. *(volatile unsigned long *)KSEG1;
  2002. a = addr & ~(dc_lsize - 1);
  2003. end = (addr + size) & ~(dc_lsize - 1);
  2004. while (1) {
  2005. flush_dcache_line(a); /* Hit_Writeback_Inv_D */
  2006. if (a == end) break;
  2007. a += dc_lsize;
  2008. }
  2009. __restore_flags(flags);
  2010. }
  2011. bc_wback_inv(addr, size);
  2012. }
  2014. static void
  2015. r4k_dma_cache_wback_inv_sc(unsigned long addr, unsigned long size)
  2016. {
  2017. unsigned long end, a;
  2019. if (size >= scache_size) {
  2020. flush_cache_all();
  2021. return;
  2022. }
  2024. a = addr & ~(sc_lsize - 1);
  2025. end = (addr + size) & ~(sc_lsize - 1);
  2026. while (1) {
  2027. flush_scache_line(a); /* Hit_Writeback_Inv_SD */
  2028. if (a == end) break;
  2029. a += sc_lsize;
  2030. }
  2031. }
  2033. static void
  2034. r4k_dma_cache_inv_pc(unsigned long addr, unsigned long size)
  2035. {
  2036. unsigned long end, a;
  2037. unsigned int flags;
  2039. if (size >= dcache_size) {
  2040. flush_cache_all();
  2041. } else {
  2042. /* Workaround for R4600 bug.  See comment above. */
  2043. __save_and_cli(flags);
  2044. *(volatile unsigned long *)KSEG1;
  2046. a = addr & ~(dc_lsize - 1);
  2047. end = (addr + size) & ~(dc_lsize - 1);
  2048. while (1) {
  2049. flush_dcache_line(a); /* Hit_Writeback_Inv_D */
  2050. if (a == end) break;
  2051. a += dc_lsize;
  2052. }
  2053. __restore_flags(flags);
  2054. }
  2056. bc_inv(addr, size);
  2057. }
  2059. static void
  2060. r4k_dma_cache_inv_sc(unsigned long addr, unsigned long size)
  2061. {
  2062. unsigned long end, a;
  2064. if (size >= scache_size) {
  2065. flush_cache_all();
  2066. return;
  2067. }
  2069. a = addr & ~(sc_lsize - 1);
  2070. end = (addr + size) & ~(sc_lsize - 1);
  2071. while (1) {
  2072. flush_scache_line(a); /* Hit_Writeback_Inv_SD */
  2073. if (a == end) break;
  2074. a += sc_lsize;
  2075. }
  2076. }
  2078. static void
  2079. r4k_dma_cache_wback(unsigned long addr, unsigned long size)
  2080. {
  2081. panic("r4k_dma_cache called - should not happen.n");
  2082. }
  2084. /*
  2085.  * While we're protected against bad userland addresses we don't care
  2086.  * very much about what happens in that case.  Usually a segmentation
  2087.  * fault will dump the process later on anyway ...
  2088.  */
  2089. static void r4k_flush_cache_sigtramp(unsigned long addr)
  2090. {
  2091. __asm__ __volatile__("nop;nop;nop;nop"); /* R4600 V1.7 */
  2092. protected_writeback_dcache_line(addr & ~(dc_lsize - 1));
  2093. protected_flush_icache_line(addr & ~(ic_lsize - 1));
  2094. }
  2096. static void r4600v20k_flush_cache_sigtramp(unsigned long addr)
  2097. {
  2098. unsigned int flags;
  2100. __save_and_cli(flags);
  2102. /* Clear internal cache refill buffer */
  2103. *(volatile unsigned int *)KSEG1;
  2105. protected_writeback_dcache_line(addr & ~(dc_lsize - 1));
  2106. protected_flush_icache_line(addr & ~(ic_lsize - 1));
  2108. __restore_flags(flags);
  2109. }
  2111. #undef DEBUG_TLB
  2112. #undef DEBUG_TLBUPDATE
  2114. void flush_tlb_all(void)
  2115. {
  2116. unsigned long flags;
  2117. unsigned long old_ctx;
  2118. int entry;
  2120. #ifdef DEBUG_TLB
  2121. printk("[tlball]");
  2122. #endif
  2124. __save_and_cli(flags);
  2125. /* Save old context and create impossible VPN2 value */
  2126. old_ctx = (get_entryhi() & 0xff);
  2127. set_entryhi(KSEG0);
  2128. set_entrylo0(0);
  2129. set_entrylo1(0);
  2130. BARRIER;
  2132. entry = get_wired();
  2134. /* Blast 'em all away. */
  2135. while(entry < mips_cpu.tlbsize) {
  2136. set_index(entry);
  2137. BARRIER;
  2138. tlb_write_indexed();
  2139. BARRIER;
  2140. entry++;
  2141. }
  2142. BARRIER;
  2143. set_entryhi(old_ctx);
  2144. __restore_flags(flags);
  2145. }
  2147. void flush_tlb_mm(struct mm_struct *mm)
  2148. {
  2149. if (mm->context != 0) {
  2150. unsigned long flags;
  2152. #ifdef DEBUG_TLB
  2153. printk("[tlbmm<%d>]", mm->context);
  2154. #endif
  2155. __save_and_cli(flags);
  2156. get_new_mmu_context(mm, asid_cache);
  2157. if (mm == current->active_mm)
  2158. set_entryhi(mm->context & 0xff);
  2159. __restore_flags(flags);
  2160. }
  2161. }
  2163. void flush_tlb_range(struct mm_struct *mm, unsigned long start,
  2164. unsigned long end)
  2165. {
  2166. if(mm->context != 0) {
  2167. unsigned long flags;
  2168. int size;
  2170. #ifdef DEBUG_TLB
  2171. printk("[tlbrange<%02x,%08lx,%08lx>]", (mm->context & 0xff),
  2172.        start, end);
  2173. #endif
  2174. __save_and_cli(flags);
  2175. size = (end - start + (PAGE_SIZE - 1)) >> PAGE_SHIFT;
  2176. size = (size + 1) >> 1;
  2177. if(size <= mips_cpu.tlbsize/2) {
  2178. int oldpid = (get_entryhi() & 0xff);
  2179. int newpid = (mm->context & 0xff);
  2181. start &= (PAGE_MASK << 1);
  2182. end += ((PAGE_SIZE << 1) - 1);
  2183. end &= (PAGE_MASK << 1);
  2184. while(start < end) {
  2185. int idx;
  2187. set_entryhi(start | newpid);
  2188. start += (PAGE_SIZE << 1);
  2189. BARRIER;
  2190. tlb_probe();
  2191. BARRIER;
  2192. idx = get_index();
  2193. set_entrylo0(0);
  2194. set_entrylo1(0);
  2195. set_entryhi(KSEG0);
  2196. BARRIER;
  2197. if(idx < 0)
  2198. continue;
  2199. tlb_write_indexed();
  2200. BARRIER;
  2201. }
  2202. set_entryhi(oldpid);
  2203. } else {
  2204. get_new_mmu_context(mm, asid_cache);
  2205. if (mm == current->active_mm)
  2206. set_entryhi(mm->context & 0xff);
  2207. }
  2208. __restore_flags(flags);
  2209. }
  2210. }
  2212. void flush_tlb_page(struct vm_area_struct *vma, unsigned long page)
  2213. {
  2214. if (vma->vm_mm->context != 0) {
  2215. unsigned long flags;
  2216. int oldpid, newpid, idx;
  2218. #ifdef DEBUG_TLB
  2219. printk("[tlbpage<%d,%08lx>]", vma->vm_mm->context, page);
  2220. #endif
  2221. newpid = (vma->vm_mm->context & 0xff);
  2222. page &= (PAGE_MASK << 1);
  2223. __save_and_cli(flags);
  2224. oldpid = (get_entryhi() & 0xff);
  2225. set_entryhi(page | newpid);
  2226. BARRIER;
  2227. tlb_probe();
  2228. BARRIER;
  2229. idx = get_index();
  2230. set_entrylo0(0);
  2231. set_entrylo1(0);
  2232. set_entryhi(KSEG0);
  2233. if(idx < 0)
  2234. goto finish;
  2235. BARRIER;
  2236. tlb_write_indexed();
  2238. finish:
  2239. BARRIER;
  2240. set_entryhi(oldpid);
  2241. __restore_flags(flags);
  2242. }
  2243. }
  2245. void pgd_init(unsigned long page)
  2246. {
  2247. unsigned long *p = (unsigned long *) page;
  2248. int i;
  2250. for(i = 0; i < USER_PTRS_PER_PGD; i+=8) {
  2251. p[i + 0] = (unsigned long) invalid_pte_table;
  2252. p[i + 1] = (unsigned long) invalid_pte_table;
  2253. p[i + 2] = (unsigned long) invalid_pte_table;
  2254. p[i + 3] = (unsigned long) invalid_pte_table;
  2255. p[i + 4] = (unsigned long) invalid_pte_table;
  2256. p[i + 5] = (unsigned long) invalid_pte_table;
  2257. p[i + 6] = (unsigned long) invalid_pte_table;
  2258. p[i + 7] = (unsigned long) invalid_pte_table;
  2259. }
  2260. }
  2262. /* We will need multiple versions of update_mmu_cache(), one that just
  2263.  * updates the TLB with the new pte(s), and another which also checks
  2264.  * for the R4k "end of page" hardware bug and does the needy.
  2265.  */
  2266. void update_mmu_cache(struct vm_area_struct * vma,
  2267.  unsigned long address, pte_t pte)
  2268. {
  2269. unsigned long flags;
  2270. pgd_t *pgdp;
  2271. pmd_t *pmdp;
  2272. pte_t *ptep;
  2273. int idx, pid;
  2275. /*
  2276.  * Handle debugger faulting in for debugee.
  2277.  */
  2278. if (current->active_mm != vma->vm_mm)
  2279. return;
  2281. pid = get_entryhi() & 0xff;
  2283. #ifdef DEBUG_TLB
  2284. if((pid != (vma->vm_mm->context & 0xff)) || (vma->vm_mm->context == 0)) {
  2285. printk("update_mmu_cache: Wheee, bogus tlbpid mmpid=%d tlbpid=%dn",
  2286.        (int) (vma->vm_mm->context & 0xff), pid);
  2287. }
  2288. #endif
  2290. __save_and_cli(flags);
  2291. address &= (PAGE_MASK << 1);
  2292. set_entryhi(address | (pid));
  2293. pgdp = pgd_offset(vma->vm_mm, address);
  2294. BARRIER;
  2295. tlb_probe();
  2296. BARRIER;
  2297. pmdp = pmd_offset(pgdp, address);
  2298. idx = get_index();
  2299. ptep = pte_offset(pmdp, address);
  2300. BARRIER;
  2301. set_entrylo0(pte_val(*ptep++) >> 6);
  2302. set_entrylo1(pte_val(*ptep) >> 6);
  2303. set_entryhi(address | (pid));
  2304. BARRIER;
  2305. if(idx < 0) {
  2306. tlb_write_random();
  2307. } else {
  2308. tlb_write_indexed();
  2309. }
  2310. BARRIER;
  2311. set_entryhi(pid);
  2312. BARRIER;
  2313. __restore_flags(flags);
  2314. }
  2316. #if 0
  2317. static void r4k_update_mmu_cache_hwbug(struct vm_area_struct * vma,
  2318.        unsigned long address, pte_t pte)
  2319. {
  2320. unsigned long flags;
  2321. pgd_t *pgdp;
  2322. pmd_t *pmdp;
  2323. pte_t *ptep;
  2324. int idx;
  2326. __save_and_cli(flags);
  2327. address &= (PAGE_MASK << 1);
  2328. set_entryhi(address | (get_entryhi() & 0xff));
  2329. pgdp = pgd_offset(vma->vm_mm, address);
  2330. tlb_probe();
  2331. pmdp = pmd_offset(pgdp, address);
  2332. idx = get_index();
  2333. ptep = pte_offset(pmdp, address);
  2334. set_entrylo0(pte_val(*ptep++) >> 6);
  2335. set_entrylo1(pte_val(*ptep) >> 6);
  2336. BARRIER;
  2337. if(idx < 0)
  2338. tlb_write_random();
  2339. else
  2340. tlb_write_indexed();
  2341. BARRIER;
  2342. __restore_flags(flags);
  2343. }
  2344. #endif
  2346. void show_regs(struct pt_regs * regs)
  2347. {
  2348. /* Saved main processor registers. */
  2349. printk("$0 : %08lx %08lx %08lx %08lxn",
  2350.        0UL, regs->regs[1], regs->regs[2], regs->regs[3]);
  2351. printk("$4 : %08lx %08lx %08lx %08lxn",
  2352.                regs->regs[4], regs->regs[5], regs->regs[6], regs->regs[7]);
  2353. printk("$8 : %08lx %08lx %08lx %08lxn",
  2354.        regs->regs[8], regs->regs[9], regs->regs[10], regs->regs[11]);
  2355. printk("$12: %08lx %08lx %08lx %08lxn",
  2356.                regs->regs[12], regs->regs[13], regs->regs[14], regs->regs[15]);
  2357. printk("$16: %08lx %08lx %08lx %08lxn",
  2358.        regs->regs[16], regs->regs[17], regs->regs[18], regs->regs[19]);
  2359. printk("$20: %08lx %08lx %08lx %08lxn",
  2360.                regs->regs[20], regs->regs[21], regs->regs[22], regs->regs[23]);
  2361. printk("$24: %08lx %08lxn",
  2362.        regs->regs[24], regs->regs[25]);
  2363. printk("$28: %08lx %08lx %08lx %08lxn",
  2364.        regs->regs[28], regs->regs[29], regs->regs[30], regs->regs[31]);
  2366. /* Saved cp0 registers. */
  2367. printk("epc   : %08lx    %snStatus: %08lxnCause : %08lxn",
  2368.        regs->cp0_epc, print_tainted(), regs->cp0_status, regs->cp0_cause);
  2369. }
  2371. void add_wired_entry(unsigned long entrylo0, unsigned long entrylo1,
  2372.       unsigned long entryhi, unsigned long pagemask)
  2373. {
  2374.         unsigned long flags;
  2375.         unsigned long wired;
  2376.         unsigned long old_pagemask;
  2377.         unsigned long old_ctx;
  2379.         __save_and_cli(flags);
  2380.         /* Save old context and create impossible VPN2 value */
  2381.         old_ctx = (get_entryhi() & 0xff);
  2382.         old_pagemask = get_pagemask();
  2383.         wired = get_wired();
  2384.         set_wired (wired + 1);
  2385.         set_index (wired);
  2386.         BARRIER;    
  2387.         set_pagemask (pagemask);
  2388.         set_entryhi(entryhi);
  2389.         set_entrylo0(entrylo0);
  2390.         set_entrylo1(entrylo1);
  2391.         BARRIER;    
  2392.         tlb_write_indexed();
  2393.         BARRIER;    
  2394.     
  2395.         set_entryhi(old_ctx);
  2396.         BARRIER;    
  2397.         set_pagemask (old_pagemask);
  2398.         flush_tlb_all();    
  2399.         __restore_flags(flags);
  2400. }
  2402. /* Detect and size the various r4k caches. */
  2403. static void __init probe_icache(unsigned long config)
  2404. {
  2405.         switch (mips_cpu.cputype) {
  2406.         case CPU_VR41XX:
  2407.                 icache_size = 1 << (10 + ((config >> 9) & 7));
  2408.                 break;
  2409.         default:
  2410.                 icache_size = 1 << (12 + ((config >> 9) & 7));
  2411.                 break;
  2412.         }
  2413. ic_lsize = 16 << ((config >> 5) & 1);
  2415. printk("Primary instruction cache %dkb, linesize %d bytes.n",
  2416.        icache_size >> 10, ic_lsize);
  2417. }
  2419. static void __init probe_dcache(unsigned long config)
  2420. {
  2421.         switch (mips_cpu.cputype) {
  2422.         case CPU_VR41XX:
  2423.                 dcache_size = 1 << (10 + ((config >> 6) & 7));
  2424.                 break;
  2425.         default:
  2426.                 dcache_size = 1 << (12 + ((config >> 6) & 7));
  2427.                 break;
  2428.         }
  2429. dc_lsize = 16 << ((config >> 4) & 1);
  2431. printk("Primary data cache %dkb, linesize %d bytes.n",
  2432.        dcache_size >> 10, dc_lsize);
  2433. }
  2436. /* If you even _breathe_ on this function, look at the gcc output
  2437.  * and make sure it does not pop things on and off the stack for
  2438.  * the cache sizing loop that executes in KSEG1 space or else
  2439.  * you will crash and burn badly.  You have been warned.
  2440.  */
  2441. static int __init probe_scache(unsigned long config)
  2442. {
  2443. extern unsigned long stext;
  2444. unsigned long flags, addr, begin, end, pow2;
  2445. int tmp;
  2447. tmp = ((config >> 17) & 1);
  2448. if(tmp)
  2449. return 0;
  2450. tmp = ((config >> 22) & 3);
  2451. switch(tmp) {
  2452. case 0:
  2453. sc_lsize = 16;
  2454. break;
  2455. case 1:
  2456. sc_lsize = 32;
  2457. break;
  2458. case 2:
  2459. sc_lsize = 64;
  2460. break;
  2461. case 3:
  2462. sc_lsize = 128;
  2463. break;
  2464. }
  2466. begin = (unsigned long) &stext;
  2467. begin &= ~((4 * 1024 * 1024) - 1);
  2468. end = begin + (4 * 1024 * 1024);
  2470. /* This is such a bitch, you'd think they would make it
  2471.  * easy to do this.  Away you daemons of stupidity!
  2472.  */
  2473. __save_and_cli(flags);
  2475. /* Fill each size-multiple cache line with a valid tag. */
  2476. pow2 = (64 * 1024);
  2477. for(addr = begin; addr < end; addr = (begin + pow2)) {
  2478. unsigned long *p = (unsigned long *) addr;
  2479. __asm__ __volatile__("nop" : : "r" (*p)); /* whee... */
  2480. pow2 <<= 1;
  2481. }
  2483. /* Load first line with zero (therefore invalid) tag. */
  2484. set_taglo(0);
  2485. set_taghi(0);
  2486. __asm__ __volatile__("nop; nop; nop; nop;"); /* avoid the hazard */
  2487. __asm__ __volatile__("nt.set noreordernt"
  2488.      ".set mips3nt"
  2489.      "cache 8, (%0)nt"
  2490.      ".set mips0nt"
  2491.      ".set reordernt" : : "r" (begin));
  2492. __asm__ __volatile__("nt.set noreordernt"
  2493.      ".set mips3nt"
  2494.      "cache 9, (%0)nt"
  2495.      ".set mips0nt"
  2496.      ".set reordernt" : : "r" (begin));
  2497. __asm__ __volatile__("nt.set noreordernt"
  2498.      ".set mips3nt"
  2499.      "cache 11, (%0)nt"
  2500.      ".set mips0nt"
  2501.      ".set reordernt" : : "r" (begin));
  2503. /* Now search for the wrap around point. */
  2504. pow2 = (128 * 1024);
  2505. tmp = 0;
  2506. for(addr = (begin + (128 * 1024)); addr < (end); addr = (begin + pow2)) {
  2507. __asm__ __volatile__("nt.set noreordernt"
  2508.      ".set mips3nt"
  2509.      "cache 7, (%0)nt"
  2510.      ".set mips0nt"
  2511.      ".set reordernt" : : "r" (addr));
  2512. __asm__ __volatile__("nop; nop; nop; nop;"); /* hazard... */
  2513. if(!get_taglo())
  2514. break;
  2515. pow2 <<= 1;
  2516. }
  2517. __restore_flags(flags);
  2518. addr -= begin;
  2519. printk("Secondary cache sized at %dK linesize %d bytes.n",
  2520.        (int) (addr >> 10), sc_lsize);
  2521. scache_size = addr;
  2522. return 1;
  2523. }
  2525. static void __init setup_noscache_funcs(void)
  2526. {
  2527. unsigned int prid;
  2529. switch(dc_lsize) {
  2530. case 16:
  2531. _clear_page = r4k_clear_page_d16;
  2532. _copy_page = r4k_copy_page_d16;
  2533. _flush_cache_all = r4k_flush_cache_all_d16i16;
  2534. _flush_cache_mm = r4k_flush_cache_mm_d16i16;
  2535. _flush_cache_range = r4k_flush_cache_range_d16i16;
  2536. _flush_cache_page = r4k_flush_cache_page_d16i16;
  2537. _flush_page_to_ram = r4k_flush_page_to_ram_d16;
  2538. break;
  2539. case 32:
  2540. prid = read_32bit_cp0_register(CP0_PRID) & 0xfff0;
  2541. if (prid == 0x2010) { /* R4600 V1.7 */
  2542. _clear_page = r4k_clear_page_r4600_v1;
  2543. _copy_page = r4k_copy_page_r4600_v1;
  2544. _flush_page_to_ram = r4k_flush_page_to_ram_d32_r4600;
  2545. } else if (prid == 0x2020) { /* R4600 V2.0 */
  2546. _clear_page = r4k_clear_page_r4600_v2;
  2547. _copy_page = r4k_copy_page_r4600_v2;
  2548. _flush_page_to_ram = r4k_flush_page_to_ram_d32;
  2549. } else {
  2550. _clear_page = r4k_clear_page_d32;
  2551. _copy_page = r4k_copy_page_d32;
  2552. _flush_page_to_ram = r4k_flush_page_to_ram_d32;
  2553. }
  2554. _flush_cache_all = r4k_flush_cache_all_d32i32;
  2555. _flush_cache_mm = r4k_flush_cache_mm_d32i32;
  2556. _flush_cache_range = r4k_flush_cache_range_d32i32;
  2557. _flush_cache_page = r4k_flush_cache_page_d32i32;
  2558. break;
  2559. }
  2560. ___flush_cache_all = _flush_cache_all;
  2562. _flush_icache_page = r4k_flush_icache_page_p;
  2564. _dma_cache_wback_inv = r4k_dma_cache_wback_inv_pc;
  2565. _dma_cache_wback = r4k_dma_cache_wback;
  2566. _dma_cache_inv = r4k_dma_cache_inv_pc;
  2567. }
  2569. static void __init setup_scache_funcs(void)
  2570. {
  2571. switch(sc_lsize) {
  2572. case 16:
  2573. switch(dc_lsize) {
  2574. case 16:
  2575. _flush_cache_all = r4k_flush_cache_all_s16d16i16;
  2576. _flush_cache_mm = r4k_flush_cache_mm_s16d16i16;
  2577. _flush_cache_range = r4k_flush_cache_range_s16d16i16;
  2578. _flush_cache_page = r4k_flush_cache_page_s16d16i16;
  2579. break;
  2580. case 32:
  2581. panic("Invalid cache configuration detected");
  2582. };
  2583. _flush_page_to_ram = r4k_flush_page_to_ram_s16;
  2584. _clear_page = r4k_clear_page_s16;
  2585. _copy_page = r4k_copy_page_s16;
  2586. break;
  2587. case 32:
  2588. switch(dc_lsize) {
  2589. case 16:
  2590. _flush_cache_all = r4k_flush_cache_all_s32d16i16;
  2591. _flush_cache_mm = r4k_flush_cache_mm_s32d16i16;
  2592. _flush_cache_range = r4k_flush_cache_range_s32d16i16;
  2593. _flush_cache_page = r4k_flush_cache_page_s32d16i16;
  2594. break;
  2595. case 32:
  2596. _flush_cache_all = r4k_flush_cache_all_s32d32i32;
  2597. _flush_cache_mm = r4k_flush_cache_mm_s32d32i32;
  2598. _flush_cache_range = r4k_flush_cache_range_s32d32i32;
  2599. _flush_cache_page = r4k_flush_cache_page_s32d32i32;
  2600. break;
  2601. };
  2602. _flush_page_to_ram = r4k_flush_page_to_ram_s32;
  2603. _clear_page = r4k_clear_page_s32;
  2604. _copy_page = r4k_copy_page_s32;
  2605. break;
  2606. case 64:
  2607. switch(dc_lsize) {
  2608. case 16:
  2609. _flush_cache_all = r4k_flush_cache_all_s64d16i16;
  2610. _flush_cache_mm = r4k_flush_cache_mm_s64d16i16;
  2611. _flush_cache_range = r4k_flush_cache_range_s64d16i16;
  2612. _flush_cache_page = r4k_flush_cache_page_s64d16i16;
  2613. break;
  2614. case 32:
  2615. _flush_cache_all = r4k_flush_cache_all_s64d32i32;
  2616. _flush_cache_mm = r4k_flush_cache_mm_s64d32i32;
  2617. _flush_cache_range = r4k_flush_cache_range_s64d32i32;
  2618. _flush_cache_page = r4k_flush_cache_page_s64d32i32;
  2619. break;
  2620. };
  2621. _flush_page_to_ram = r4k_flush_page_to_ram_s64;
  2622. _clear_page = r4k_clear_page_s64;
  2623. _copy_page = r4k_copy_page_s64;
  2624. break;
  2625. case 128:
  2626. switch(dc_lsize) {
  2627. case 16:
  2628. _flush_cache_all = r4k_flush_cache_all_s128d16i16;
  2629. _flush_cache_mm = r4k_flush_cache_mm_s128d16i16;
  2630. _flush_cache_range = r4k_flush_cache_range_s128d16i16;
  2631. _flush_cache_page = r4k_flush_cache_page_s128d16i16;
  2632. break;
  2633. case 32:
  2634. _flush_cache_all = r4k_flush_cache_all_s128d32i32;
  2635. _flush_cache_mm = r4k_flush_cache_mm_s128d32i32;
  2636. _flush_cache_range = r4k_flush_cache_range_s128d32i32;
  2637. _flush_cache_page = r4k_flush_cache_page_s128d32i32;
  2638. break;
  2639. };
  2640. _flush_page_to_ram = r4k_flush_page_to_ram_s128;
  2641. _clear_page = r4k_clear_page_s128;
  2642. _copy_page = r4k_copy_page_s128;
  2643. break;
  2644. }
  2645. ___flush_cache_all = _flush_cache_all;
  2646. _flush_icache_page = r4k_flush_icache_page_s;
  2647. _dma_cache_wback_inv = r4k_dma_cache_wback_inv_sc;
  2648. _dma_cache_wback = r4k_dma_cache_wback;
  2649. _dma_cache_inv = r4k_dma_cache_inv_sc;
  2650. }
  2652. typedef int (*probe_func_t)(unsigned long);
  2654. static inline void __init setup_scache(unsigned int config)
  2655. {
  2656. probe_func_t probe_scache_kseg1;
  2657. int sc_present = 0;
  2659. /* Maybe the cpu knows about a l2 cache? */
  2660. probe_scache_kseg1 = (probe_func_t) (KSEG1ADDR(&probe_scache));
  2661. sc_present = probe_scache_kseg1(config);
  2663. if (sc_present) {
  2664. setup_scache_funcs();
  2665. return;
  2666. }
  2668. setup_noscache_funcs();
  2669. }
  2671. void __init ld_mmu_r4xx0(void)
  2672. {
  2673. unsigned long config = read_32bit_cp0_register(CP0_CONFIG);
  2675. printk("CPU revision is: %08xn", read_32bit_cp0_register(CP0_PRID));
  2677. #ifdef CONFIG_MIPS_UNCACHED
  2678. change_cp0_config(CONF_CM_CMASK, CONF_CM_UNCACHED);
  2679. #else
  2680. change_cp0_config(CONF_CM_CMASK, CONF_CM_CACHABLE_NONCOHERENT);
  2681. #endif
  2683. probe_icache(config);
  2684. probe_dcache(config);
  2685. setup_scache(config);
  2687. switch(mips_cpu.cputype) {
  2688. case CPU_R4600: /* QED style two way caches? */
  2689. case CPU_R4700:
  2690. case CPU_R5000:
  2691. case CPU_NEVADA:
  2692. _flush_cache_page = r4k_flush_cache_page_d32i32_r4600;
  2693. }
  2695. _flush_cache_sigtramp = r4k_flush_cache_sigtramp;
  2696. _flush_icache_range = r4k_flush_icache_range; /* Ouch */
  2697. if ((read_32bit_cp0_register(CP0_PRID) & 0xfff0) == 0x2020) {
  2698. _flush_cache_sigtramp = r4600v20k_flush_cache_sigtramp;
  2699. }
  2701. __flush_cache_all();
  2702. write_32bit_cp0_register(CP0_WIRED, 0);
  2704. /*
  2705.  * You should never change this register:
  2706.  *   - On R4600 1.7 the tlbp never hits for pages smaller than
  2707.  *     the value in the c0_pagemask register.
  2708.  *   - The entire mm handling assumes the c0_pagemask register to
  2709.  *     be set for 4kb pages.
  2710.  */
  2711. set_pagemask(PM_4K);
  2712. flush_tlb_all();
  2713. }