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

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

Linux/Unix编程

开发平台：

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, 2001 Ralf Baechle (ralf@gnu.org)
  10.  * Copyright (C) 1999, 2000 Silicon Graphics, Inc.
  11.  */
  12. #include <linux/config.h>
  13. #include <linux/init.h>
  14. #include <linux/kernel.h>
  15. #include <linux/sched.h>
  16. #include <linux/mm.h>
  18. #include <asm/bcache.h>
  19. #include <asm/io.h>
  20. #include <asm/page.h>
  21. #include <asm/pgtable.h>
  22. #include <asm/system.h>
  23. #include <asm/bootinfo.h>
  24. #include <asm/mmu_context.h>
  25. #include <asm/cpu.h>
  27. /* CP0 hazard avoidance. */
  28. #define BARRIER __asm__ __volatile__(".set noreordernt" 
  29.      "nop; nop; nop; nop; nop; nop;nt" 
  30.      ".set reordernt")
  32. /* Primary cache parameters. */
  33. static int icache_size, dcache_size; /* Size in bytes */
  34. static int ic_lsize, dc_lsize;       /* LineSize in bytes */
  36. /* Secondary cache (if present) parameters. */
  37. static unsigned int scache_size, sc_lsize; /* Again, in bytes */
  39. #include <asm/r4kcacheops.h>
  40. #include <asm/r4kcache.h>
  42. #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.  * Zero an entire page.  Basically a simple unrolled loop should do the
  67.  * job but we want more performance by saving memory bus bandwidth.  We
  68.  * have five flavours of the routine available for:
  69.  *
  70.  * - 16byte cachelines and no second level cache
  71.  * - 32byte cachelines second level cache
  72.  * - a version which handles the buggy R4600 v1.x
  73.  * - a version which handles the buggy R4600 v2.0
  74.  * - Finally a last version without fancy cache games for the SC and MC
  75.  *   versions of R4000 and R4400.
  76.  */
  78. static void r4k_clear_page_d16(void * page)
  79. {
  80. __asm__ __volatile__(
  81. ".settnoreordernt"
  82. ".settnoatnt"
  83. "daddiut$1,%0,%2n"
  84. "1:tcachet%3,(%0)nt"
  85. "sdt$0,(%0)nt"
  86. "sdt$0,8(%0)nt"
  87. "cachet%3,16(%0)nt"
  88. "sdt$0,16(%0)nt"
  89. "sdt$0,24(%0)nt"
  90. "daddiut%0,64nt"
  91. "cachet%3,-32(%0)nt"
  92. "sdt$0,-32(%0)nt"
  93. "sdt$0,-24(%0)nt"
  94. "cachet%3,-16(%0)nt"
  95. "sdt$0,-16(%0)nt"
  96. "bnet$1,%0,1bnt"
  97. "sdt$0,-8(%0)nt"
  98. ".settatnt"
  99. ".settreorder"
  100. : "=r" (page)
  101. : "0" (page), "I" (PAGE_SIZE), "i" (Create_Dirty_Excl_D)
  102. : "memory");
  103. }
  105. static void r4k_clear_page_d32(void * page)
  106. {
  107. __asm__ __volatile__(
  108. ".settnoreordernt"
  109. ".settnoatnt"
  110. "daddiut$1,%0,%2n"
  111. "1:tcachet%3,(%0)nt"
  112. "sdt$0,(%0)nt"
  113. "sdt$0,8(%0)nt"
  114. "sdt$0,16(%0)nt"
  115. "sdt$0,24(%0)nt"
  116. "daddiut%0,64nt"
  117. "cachet%3,-32(%0)nt"
  118. "sdt$0,-32(%0)nt"
  119. "sdt$0,-24(%0)nt"
  120. "sdt$0,-16(%0)nt"
  121. "bnet$1,%0,1bnt"
  122. "sdt$0,-8(%0)nt"
  123. ".settatnt"
  124. ".settreorder"
  125. : "=r" (page)
  126. : "0" (page), "I" (PAGE_SIZE), "i" (Create_Dirty_Excl_D)
  127. : "memory");
  128. }
  131. /*
  132.  * This flavour of r4k_clear_page is for the R4600 V1.x.  Cite from the
  133.  * IDT R4600 V1.7 errata:
  134.  *
  135.  *  18. The CACHE instructions Hit_Writeback_Invalidate_D, Hit_Writeback_D,
  136.  *      Hit_Invalidate_D and Create_Dirty_Excl_D should only be
  137.  *      executed if there is no other dcache activity. If the dcache is
  138.  *      accessed for another instruction immeidately preceding when these
  139.  *      cache instructions are executing, it is possible that the dcache
  140.  *      tag match outputs used by these cache instructions will be
  141.  *      incorrect. These cache instructions should be preceded by at least
  142.  *      four instructions that are not any kind of load or store
  143.  *      instruction.
  144.  *
  145.  *      This is not allowed:    lw
  146.  *                              nop
  147.  *                              nop
  148.  *                              nop
  149.  *                              cache       Hit_Writeback_Invalidate_D
  150.  *
  151.  *      This is allowed:        lw
  152.  *                              nop
  153.  *                              nop
  154.  *                              nop
  155.  *                              nop
  156.  *                              cache       Hit_Writeback_Invalidate_D
  157.  */
  158. static void r4k_clear_page_r4600_v1(void * page)
  159. {
  160. __asm__ __volatile__(
  161. ".settnoreordernt"
  162. ".settnoatnt"
  163. "daddiut$1,%0,%2n"
  164. "1:tnopnt"
  165. "nopnt"
  166. "nopnt"
  167. "nopnt"
  168. "cachet%3,(%0)nt"
  169. "sdt$0,(%0)nt"
  170. "sdt$0,8(%0)nt"
  171. "sdt$0,16(%0)nt"
  172. "sdt$0,24(%0)nt"
  173. "daddiut%0,64nt"
  174. "nopnt"
  175. "nopnt"
  176. "nopnt"
  177. "cachet%3,-32(%0)nt"
  178. "sdt$0,-32(%0)nt"
  179. "sdt$0,-24(%0)nt"
  180. "sdt$0,-16(%0)nt"
  181. "bnet$1,%0,1bnt"
  182. "sdt$0,-8(%0)nt"
  183. ".settatnt"
  184. ".settreorder"
  185. : "=r" (page)
  186. : "0" (page), "I" (PAGE_SIZE), "i" (Create_Dirty_Excl_D)
  187. : "memory");
  188. }
  190. /*
  191.  * And this one is for the R4600 V2.0
  192.  */
  193. static void r4k_clear_page_r4600_v2(void * page)
  194. {
  195. unsigned int flags;
  197. __save_and_cli(flags);
  198. *(volatile unsigned int *)KSEG1;
  199. __asm__ __volatile__(
  200. ".settnoreordernt"
  201. ".settnoatnt"
  202. "daddiut$1,%0,%2n"
  203. "1:tcachet%3,(%0)nt"
  204. "sdt$0,(%0)nt"
  205. "sdt$0,8(%0)nt"
  206. "sdt$0,16(%0)nt"
  207. "sdt$0,24(%0)nt"
  208. "daddiut%0,64nt"
  209. "cachet%3,-32(%0)nt"
  210. "sdt$0,-32(%0)nt"
  211. "sdt$0,-24(%0)nt"
  212. "sdt$0,-16(%0)nt"
  213. "bnet$1,%0,1bnt"
  214. "sdt$0,-8(%0)nt"
  215. ".settatnt"
  216. ".settreorder"
  217. : "=r" (page)
  218. : "0" (page), "I" (PAGE_SIZE), "i" (Create_Dirty_Excl_D)
  219. : "memory");
  220. __restore_flags(flags);
  221. }
  223. /*
  224.  * The next 4 versions are optimized for all possible scache configurations
  225.  * of the SC / MC versions of R4000 and R4400 ...
  226.  *
  227.  * Todo: For even better performance we should have a routine optimized for
  228.  * every legal combination of dcache / scache linesize.  When I (Ralf) tried
  229.  * this the kernel crashed shortly after mounting the root filesystem.  CPU
  230.  * bug?  Weirdo cache instruction semantics?
  231.  */
  232. static void r4k_clear_page_s16(void * page)
  233. {
  234. __asm__ __volatile__(
  235. ".settnoreordernt"
  236. ".settnoatnt"
  237. "daddiut$1,%0,%2n"
  238. "1:tcachet%3,(%0)nt"
  239. "sdt$0,(%0)nt"
  240. "sdt$0,8(%0)nt"
  241. "cachet%3,16(%0)nt"
  242. "sdt$0,16(%0)nt"
  243. "sdt$0,24(%0)nt"
  244. "daddiut%0,64nt"
  245. "cachet%3,-32(%0)nt"
  246. "sdt$0,-32(%0)nt"
  247. "sdt$0,-24(%0)nt"
  248. "cachet%3,-16(%0)nt"
  249. "sdt$0,-16(%0)nt"
  250. "bnet$1,%0,1bnt"
  251. "sdt$0,-8(%0)nt"
  252. ".settatnt"
  253. ".settreorder"
  254. : "=r" (page)
  255. : "0" (page), "I" (PAGE_SIZE), "i" (Create_Dirty_Excl_SD)
  256. : "memory");
  257. }
  259. static void r4k_clear_page_s32(void * page)
  260. {
  261. __asm__ __volatile__(
  262. ".settnoreordernt"
  263. ".settnoatnt"
  264. "daddiut$1,%0,%2n"
  265. "1:tcachet%3,(%0)nt"
  266. "sdt$0,(%0)nt"
  267. "sdt$0,8(%0)nt"
  268. "sdt$0,16(%0)nt"
  269. "sdt$0,24(%0)nt"
  270. "daddiut%0,64nt"
  271. "cachet%3,-32(%0)nt"
  272. "sdt$0,-32(%0)nt"
  273. "sdt$0,-24(%0)nt"
  274. "sdt$0,-16(%0)nt"
  275. "bnet$1,%0,1bnt"
  276. "sdt$0,-8(%0)nt"
  277. ".settatnt"
  278. ".settreorder"
  279. : "=r" (page)
  280. : "0" (page), "I" (PAGE_SIZE), "i" (Create_Dirty_Excl_SD)
  281. : "memory");
  282. }
  284. static void r4k_clear_page_s64(void * page)
  285. {
  286. __asm__ __volatile__(
  287. ".settnoreordernt"
  288. ".settnoatnt"
  289. "daddiut$1,%0,%2n"
  290. "1:tcachet%3,(%0)nt"
  291. "sdt$0,(%0)nt"
  292. "sdt$0,8(%0)nt"
  293. "sdt$0,16(%0)nt"
  294. "sdt$0,24(%0)nt"
  295. "daddiut%0,64nt"
  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. ".settatnt"
  302. ".settreorder"
  303. : "=r" (page)
  304. : "0" (page), "I" (PAGE_SIZE), "i" (Create_Dirty_Excl_SD)
  305. : "memory");
  306. }
  308. static void r4k_clear_page_s128(void * page)
  309. {
  310. __asm__ __volatile__(
  311. ".settnoreordernt"
  312. ".settnoatnt"
  313. "daddiut$1,%0,%2n"
  314. "1:tcachet%3,(%0)nt"
  315. "sdt$0,(%0)nt"
  316. "sdt$0,8(%0)nt"
  317. "sdt$0,16(%0)nt"
  318. "sdt$0,24(%0)nt"
  319. "sdt$0,32(%0)nt"
  320. "sdt$0,40(%0)nt"
  321. "sdt$0,48(%0)nt"
  322. "sdt$0,56(%0)nt"
  323. "daddiut%0,128nt"
  324. "sdt$0,-64(%0)nt"
  325. "sdt$0,-56(%0)nt"
  326. "sdt$0,-48(%0)nt"
  327. "sdt$0,-40(%0)nt"
  328. "sdt$0,-32(%0)nt"
  329. "sdt$0,-24(%0)nt"
  330. "sdt$0,-16(%0)nt"
  331. "bnet$1,%0,1bnt"
  332. "sdt$0,-8(%0)nt"
  333. ".settatnt"
  334. ".settreorder"
  335. : "=r" (page)
  336. : "0" (page), "I" (PAGE_SIZE), "i" (Create_Dirty_Excl_SD)
  337. : "memory");
  338. }
  341. /*
  342.  * This is still inefficient.  We only can do better if we know the
  343.  * virtual address where the copy will be accessed.
  344.  */
  346. static void r4k_copy_page_d16(void * to, void * from)
  347. {
  348. unsigned long dummy1, dummy2, reg1, reg2;
  350. __asm__ __volatile__(
  351. ".settnoreordernt"
  352. ".settnoatnt"
  353. "daddiut$1,%0,%6n"
  354. "1:tcachet%7,(%0)nt"
  355. "ldt%2,(%1)nt"
  356. "ldt%3,8(%1)nt"
  357. "sdt%2,(%0)nt"
  358. "sdt%3,8(%0)nt"
  359. "cachet%7,16(%0)nt"
  360. "ldt%2,16(%1)nt"
  361. "ldt%3,24(%1)nt"
  362. "sdt%2,16(%0)nt"
  363. "sdt%3,24(%0)nt"
  364. "cachet%7,32(%0)nt"
  365. "daddiut%0,64nt"
  366. "daddiut%1,64nt"
  367. "ldt%2,-32(%1)nt"
  368. "ldt%3,-24(%1)nt"
  369. "sdt%2,-32(%0)nt"
  370. "sdt%3,-24(%0)nt"
  371. "cachet%7,-16(%0)nt"
  372. "ldt%2,-16(%1)nt"
  373. "ldt%3,-8(%1)nt"
  374. "sdt%2,-16(%0)nt"
  375. "bnet$1,%0,1bnt"
  376. " sdt%3,-8(%0)nt"
  377. ".settatnt"
  378. ".settreorder"
  379. :"=r" (dummy1), "=r" (dummy2), "=&r" (reg1), "=&r" (reg2)
  380. :"0" (to), "1" (from), "I" (PAGE_SIZE),
  381.  "i" (Create_Dirty_Excl_D));
  382. }
  384. static void r4k_copy_page_d32(void * to, void * from)
  385. {
  386. unsigned long dummy1, dummy2, reg1, reg2;
  388. __asm__ __volatile__(
  389. ".settnoreordernt"
  390. ".settnoatnt"
  391. "daddiut$1,%0,%6n"
  392. "1:tcachet%7,(%0)nt"
  393. "ldt%2,(%1)nt"
  394. "ldt%3,8(%1)nt"
  395. "sdt%2,(%0)nt"
  396. "sdt%3,8(%0)nt"
  397. "ldt%2,16(%1)nt"
  398. "ldt%3,24(%1)nt"
  399. "sdt%2,16(%0)nt"
  400. "sdt%3,24(%0)nt"
  401. "cachet%7,32(%0)nt"
  402. "daddiut%0,64nt"
  403. "daddiut%1,64nt"
  404. "ldt%2,-32(%1)nt"
  405. "ldt%3,-24(%1)nt"
  406. "sdt%2,-32(%0)nt"
  407. "sdt%3,-24(%0)nt"
  408. "ldt%2,-16(%1)nt"
  409. "ldt%3,-8(%1)nt"
  410. "sdt%2,-16(%0)nt"
  411. "bnet$1,%0,1bnt"
  412. " sdt%3,-8(%0)nt"
  413. ".settatnt"
  414. ".settreorder"
  415. :"=r" (dummy1), "=r" (dummy2), "=&r" (reg1), "=&r" (reg2)
  416. :"0" (to), "1" (from), "I" (PAGE_SIZE),
  417.  "i" (Create_Dirty_Excl_D));
  418. }
  420. /*
  421.  * Again a special version for the R4600 V1.x
  422.  */
  423. static void r4k_copy_page_r4600_v1(void * to, void * from)
  424. {
  425. unsigned long dummy1, dummy2, reg1, reg2;
  427. __asm__ __volatile__(
  428. ".settnoreordernt"
  429. ".settnoatnt"
  430. "daddiut$1,%0,%6n"
  431. "1:tnopnt"
  432. "nopnt"
  433. "nopnt"
  434. "nopnt"
  435. "tcachet%7,(%0)nt"
  436. "ldt%2,(%1)nt"
  437. "ldt%3,8(%1)nt"
  438. "sdt%2,(%0)nt"
  439. "sdt%3,8(%0)nt"
  440. "ldt%2,16(%1)nt"
  441. "ldt%3,24(%1)nt"
  442. "sdt%2,16(%0)nt"
  443. "sdt%3,24(%0)nt"
  444. "nopnt"
  445. "nopnt"
  446. "nopnt"
  447. "nopnt"
  448. "cachet%7,32(%0)nt"
  449. "daddiut%0,64nt"
  450. "daddiut%1,64nt"
  451. "ldt%2,-32(%1)nt"
  452. "ldt%3,-24(%1)nt"
  453. "sdt%2,-32(%0)nt"
  454. "sdt%3,-24(%0)nt"
  455. "ldt%2,-16(%1)nt"
  456. "ldt%3,-8(%1)nt"
  457. "sdt%2,-16(%0)nt"
  458. "bnet$1,%0,1bnt"
  459. " sdt%3,-8(%0)nt"
  460. ".settatnt"
  461. ".settreorder"
  462. :"=r" (dummy1), "=r" (dummy2), "=&r" (reg1), "=&r" (reg2)
  463. :"0" (to), "1" (from), "I" (PAGE_SIZE),
  464.  "i" (Create_Dirty_Excl_D));
  465. }
  467. static void r4k_copy_page_r4600_v2(void * to, void * from)
  468. {
  469. unsigned long dummy1, dummy2, reg1, reg2;
  470. unsigned int flags;
  472. __save_and_cli(flags);
  473. __asm__ __volatile__(
  474. ".settnoreordernt"
  475. ".settnoatnt"
  476. "daddiut$1,%0,%6n"
  477. "1:tnopnt"
  478. "nopnt"
  479. "nopnt"
  480. "nopnt"
  481. "tcachet%7,(%0)nt"
  482. "ldt%2,(%1)nt"
  483. "ldt%3,8(%1)nt"
  484. "sdt%2,(%0)nt"
  485. "sdt%3,8(%0)nt"
  486. "ldt%2,16(%1)nt"
  487. "ldt%3,24(%1)nt"
  488. "sdt%2,16(%0)nt"
  489. "sdt%3,24(%0)nt"
  490. "nopnt"
  491. "nopnt"
  492. "nopnt"
  493. "nopnt"
  494. "cachet%7,32(%0)nt"
  495. "daddiut%0,64nt"
  496. "daddiut%1,64nt"
  497. "ldt%2,-32(%1)nt"
  498. "ldt%3,-24(%1)nt"
  499. "sdt%2,-32(%0)nt"
  500. "sdt%3,-24(%0)nt"
  501. "ldt%2,-16(%1)nt"
  502. "ldt%3,-8(%1)nt"
  503. "sdt%2,-16(%0)nt"
  504. "bnet$1,%0,1bnt"
  505. " sdt%3,-8(%0)nt"
  506. ".settatnt"
  507. ".settreorder"
  508. :"=r" (dummy1), "=r" (dummy2), "=&r" (reg1), "=&r" (reg2)
  509. :"0" (to), "1" (from), "I" (PAGE_SIZE),
  510.  "i" (Create_Dirty_Excl_D));
  511. __restore_flags(flags);
  512. }
  514. /*
  515.  * These are for R4000SC / R4400MC
  516.  */
  517. static void r4k_copy_page_s16(void * to, void * from)
  518. {
  519. unsigned long dummy1, dummy2, reg1, reg2;
  521. __asm__ __volatile__(
  522. ".settnoreordernt"
  523. ".settnoatnt"
  524. "daddiut$1,%0,%6n"
  525. "1:tcachet%7,(%0)nt"
  526. "ldt%2,(%1)nt"
  527. "ldt%3,8(%1)nt"
  528. "sdt%2,(%0)nt"
  529. "sdt%3,8(%0)nt"
  530. "cachet%7,16(%0)nt"
  531. "ldt%2,16(%1)nt"
  532. "ldt%3,24(%1)nt"
  533. "sdt%2,16(%0)nt"
  534. "sdt%3,24(%0)nt"
  535. "cachet%7,32(%0)nt"
  536. "daddiut%0,64nt"
  537. "daddiut%1,64nt"
  538. "ldt%2,-32(%1)nt"
  539. "ldt%3,-24(%1)nt"
  540. "sdt%2,-32(%0)nt"
  541. "sdt%3,-24(%0)nt"
  542. "cachet%7,-16(%0)nt"
  543. "ldt%2,-16(%1)nt"
  544. "ldt%3,-8(%1)nt"
  545. "sdt%2,-16(%0)nt"
  546. "bnet$1,%0,1bnt"
  547. " sdt%3,-8(%0)nt"
  548. ".settatnt"
  549. ".settreorder"
  550. :"=r" (dummy1), "=r" (dummy2), "=&r" (reg1), "=&r" (reg2)
  551. :"0" (to), "1" (from), "I" (PAGE_SIZE),
  552.  "i" (Create_Dirty_Excl_SD));
  553. }
  555. static void r4k_copy_page_s32(void * to, void * from)
  556. {
  557. unsigned long dummy1, dummy2, reg1, reg2;
  559. __asm__ __volatile__(
  560. ".settnoreordernt"
  561. ".settnoatnt"
  562. "daddiut$1,%0,%6n"
  563. "1:tcachet%7,(%0)nt"
  564. "ldt%2,(%1)nt"
  565. "ldt%3,8(%1)nt"
  566. "sdt%2,(%0)nt"
  567. "sdt%3,8(%0)nt"
  568. "ldt%2,16(%1)nt"
  569. "ldt%3,24(%1)nt"
  570. "sdt%2,16(%0)nt"
  571. "sdt%3,24(%0)nt"
  572. "cachet%7,32(%0)nt"
  573. "daddiut%0,64nt"
  574. "daddiut%1,64nt"
  575. "ldt%2,-32(%1)nt"
  576. "ldt%3,-24(%1)nt"
  577. "sdt%2,-32(%0)nt"
  578. "sdt%3,-24(%0)nt"
  579. "ldt%2,-16(%1)nt"
  580. "ldt%3,-8(%1)nt"
  581. "sdt%2,-16(%0)nt"
  582. "bnet$1,%0,1bnt"
  583. " sdt%3,-8(%0)nt"
  584. ".settatnt"
  585. ".settreorder"
  586. :"=r" (dummy1), "=r" (dummy2), "=&r" (reg1), "=&r" (reg2)
  587. :"0" (to), "1" (from), "I" (PAGE_SIZE),
  588.  "i" (Create_Dirty_Excl_SD));
  589. }
  591. static void r4k_copy_page_s64(void * to, void * from)
  592. {
  593. unsigned long dummy1, dummy2, reg1, reg2;
  595. __asm__ __volatile__(
  596. ".settnoreordernt"
  597. ".settnoatnt"
  598. "daddiut$1,%0,%6n"
  599. "1:tcachet%7,(%0)nt"
  600. "ldt%2,(%1)nt"
  601. "ldt%3,8(%1)nt"
  602. "sdt%2,(%0)nt"
  603. "sdt%3,8(%0)nt"
  604. "ldt%2,16(%1)nt"
  605. "ldt%3,24(%1)nt"
  606. "sdt%2,16(%0)nt"
  607. "sdt%3,24(%0)nt"
  608. "daddiut%0,64nt"
  609. "daddiut%1,64nt"
  610. "ldt%2,-32(%1)nt"
  611. "ldt%3,-24(%1)nt"
  612. "sdt%2,-32(%0)nt"
  613. "sdt%3,-24(%0)nt"
  614. "ldt%2,-16(%1)nt"
  615. "ldt%3,-8(%1)nt"
  616. "sdt%2,-16(%0)nt"
  617. "bnet$1,%0,1bnt"
  618. " sdt%3,-8(%0)nt"
  619. ".settatnt"
  620. ".settreorder"
  621. :"=r" (dummy1), "=r" (dummy2), "=&r" (reg1), "=&r" (reg2)
  622. :"0" (to), "1" (from), "I" (PAGE_SIZE),
  623.  "i" (Create_Dirty_Excl_SD));
  624. }
  626. static void r4k_copy_page_s128(void * to, void * from)
  627. {
  628. unsigned long dummy1, dummy2;
  629. unsigned long reg1, reg2, reg3, reg4;
  631. __asm__ __volatile__(
  632. ".settnoreordernt"
  633. ".settnoatnt"
  634. "daddiut$1,%0,%8n"
  635. "1:tcachet%9,(%0)nt"
  636. "ldt%2,(%1)nt"
  637. "ldt%3,8(%1)nt"
  638. "ldt%4,16(%1)nt"
  639. "ldt%5,24(%1)nt"
  640. "sdt%2,(%0)nt"
  641. "sdt%3,8(%0)nt"
  642. "sdt%4,16(%0)nt"
  643. "sdt%5,24(%0)nt"
  644. "ldt%2,32(%1)nt"
  645. "ldt%3,40(%1)nt"
  646. "ldt%4,48(%1)nt"
  647. "ldt%5,56(%1)nt"
  648. "sdt%2,32(%0)nt"
  649. "sdt%3,40(%0)nt"
  650. "sdt%4,48(%0)nt"
  651. "sdt%5,56(%0)nt"
  652. "daddiut%0,128nt"
  653. "daddiut%1,128nt"
  654. "ldt%2,-64(%1)nt"
  655. "ldt%3,-56(%1)nt"
  656. "ldt%4,-48(%1)nt"
  657. "ldt%5,-40(%1)nt"
  658. "sdt%2,-64(%0)nt"
  659. "sdt%3,-56(%0)nt"
  660. "sdt%4,-48(%0)nt"
  661. "sdt%5,-40(%0)nt"
  662. "ldt%2,-32(%1)nt"
  663. "ldt%3,-24(%1)nt"
  664. "ldt%4,-16(%1)nt"
  665. "ldt%5,-8(%1)nt"
  666. "sdt%2,-32(%0)nt"
  667. "sdt%3,-24(%0)nt"
  668. "sdt%4,-16(%0)nt"
  669. "bnet$1,%0,1bnt"
  670. " sdt%5,-8(%0)nt"
  671. ".settatnt"
  672. ".settreorder"
  673. :"=r" (dummy1), "=r" (dummy2),
  674.  "=&r" (reg1), "=&r" (reg2), "=&r" (reg3), "=&r" (reg4)
  675. :"0" (to), "1" (from),
  676.  "I" (PAGE_SIZE),
  677.  "i" (Create_Dirty_Excl_SD));
  678. }
  681. /*
  682.  * If you think for one second that this stuff coming up is a lot
  683.  * of bulky code eating too many kernel cache lines.  Think _again_.
  684.  *
  685.  * Consider:
  686.  * 1) Taken branches have a 3 cycle penalty on R4k
  687.  * 2) The branch itself is a real dead cycle on even R4600/R5000.
  688.  * 3) Only one of the following variants of each type is even used by
  689.  *    the kernel based upon the cache parameters we detect at boot time.
  690.  *
  691.  * QED.
  692.  */
  694. static inline void r4k_flush_cache_all_s16d16i16(void)
  695. {
  696. blast_dcache16(); blast_icache16(); blast_scache16();
  697. }
  699. static inline void r4k_flush_cache_all_s32d16i16(void)
  700. {
  701. blast_dcache16(); blast_icache16(); blast_scache32();
  702. }
  704. static inline void r4k_flush_cache_all_s64d16i16(void)
  705. {
  706. blast_dcache16(); blast_icache16(); blast_scache64();
  707. }
  709. static inline void r4k_flush_cache_all_s128d16i16(void)
  710. {
  711. blast_dcache16(); blast_icache16(); blast_scache128();
  712. }
  714. static inline void r4k_flush_cache_all_s32d32i32(void)
  715. {
  716. blast_dcache32(); blast_icache32(); blast_scache32();
  717. }
  719. static inline void r4k_flush_cache_all_s64d32i32(void)
  720. {
  721. blast_dcache32(); blast_icache32(); blast_scache64();
  722. }
  724. static inline void r4k_flush_cache_all_s128d32i32(void)
  725. {
  726. blast_dcache32(); blast_icache32(); blast_scache128();
  727. }
  729. static inline void r4k_flush_cache_all_d16i16(void)
  730. {
  731. blast_dcache16(); blast_icache16();
  732. }
  734. static inline void r4k_flush_cache_all_d32i32(void)
  735. {
  736. blast_dcache32(); blast_icache32();
  737. }
  739. static void r4k_flush_cache_range_s16d16i16(struct mm_struct *mm,
  740.     unsigned long start,
  741.     unsigned long end)
  742. {
  743. struct vm_area_struct *vma;
  745. if (CPU_CONTEXT(smp_processor_id(), mm) == 0)
  746. return;
  748. start &= PAGE_MASK;
  749. #ifdef DEBUG_CACHE
  750. printk("crange[%d,%08lx,%08lx]", (int)mm->context, start, end);
  751. #endif
  752. vma = find_vma(mm, start);
  753. if(vma) {
  754. if (CPU_CONTEXT(smp_processor_id(), mm) !=
  755. CPU_CONTEXT(smp_processor_id(), current->mm)) {
  756. r4k_flush_cache_all_s16d16i16();
  757. } else {
  758. pgd_t *pgd;
  759. pmd_t *pmd;
  760. pte_t *pte;
  762. while(start < end) {
  763. pgd = pgd_offset(mm, start);
  764. pmd = pmd_offset(pgd, start);
  765. pte = pte_offset(pmd, start);
  767. if(pte_val(*pte) & _PAGE_VALID)
  768. blast_scache16_page(start);
  769. start += PAGE_SIZE;
  770. }
  771. }
  772. }
  773. }
  775. static void r4k_flush_cache_range_s32d16i16(struct mm_struct *mm,
  776.     unsigned long start,
  777.     unsigned long end)
  778. {
  779. struct vm_area_struct *vma;
  781. if (CPU_CONTEXT(smp_processor_id(), mm) == 0)
  782. return;
  784. start &= PAGE_MASK;
  785. #ifdef DEBUG_CACHE
  786. printk("crange[%d,%08lx,%08lx]", (int)mm->context, start, end);
  787. #endif
  788. vma = find_vma(mm, start);
  789. if(vma) {
  790. if (CPU_CONTEXT(smp_processor_id(), mm) !=
  791. CPU_CONTEXT(smp_processor_id(), current->mm)) {
  792. r4k_flush_cache_all_s32d16i16();
  793. } else {
  794. pgd_t *pgd;
  795. pmd_t *pmd;
  796. pte_t *pte;
  798. while(start < end) {
  799. pgd = pgd_offset(mm, start);
  800. pmd = pmd_offset(pgd, start);
  801. pte = pte_offset(pmd, start);
  803. if(pte_val(*pte) & _PAGE_VALID)
  804. blast_scache32_page(start);
  805. start += PAGE_SIZE;
  806. }
  807. }
  808. }
  809. }
  811. static void r4k_flush_cache_range_s64d16i16(struct mm_struct *mm,
  812.     unsigned long start,
  813.     unsigned long end)
  814. {
  815. struct vm_area_struct *vma;
  817. if (CPU_CONTEXT(smp_processor_id(), mm) == 0)
  818. return;
  820. start &= PAGE_MASK;
  821. #ifdef DEBUG_CACHE
  822. printk("crange[%d,%08lx,%08lx]", (int)mm->context, start, end);
  823. #endif
  824. vma = find_vma(mm, start);
  825. if(vma) {
  826. if (CPU_CONTEXT(smp_processor_id(), mm) !=
  827. CPU_CONTEXT(smp_processor_id(), current->mm)) {
  828. r4k_flush_cache_all_s64d16i16();
  829. } else {
  830. pgd_t *pgd;
  831. pmd_t *pmd;
  832. pte_t *pte;
  834. while(start < end) {
  835. pgd = pgd_offset(mm, start);
  836. pmd = pmd_offset(pgd, start);
  837. pte = pte_offset(pmd, start);
  839. if(pte_val(*pte) & _PAGE_VALID)
  840. blast_scache64_page(start);
  841. start += PAGE_SIZE;
  842. }
  843. }
  844. }
  845. }
  847. static void r4k_flush_cache_range_s128d16i16(struct mm_struct *mm,
  848.      unsigned long start,
  849.      unsigned long end)
  850. {
  851. struct vm_area_struct *vma;
  853. if (CPU_CONTEXT(smp_processor_id(), mm) == 0)
  854. return;
  856. start &= PAGE_MASK;
  857. #ifdef DEBUG_CACHE
  858. printk("crange[%d,%08lx,%08lx]", (int)mm->context, start, end);
  859. #endif
  860. vma = find_vma(mm, start);
  861. if(vma) {
  862. if (CPU_CONTEXT(smp_processor_id(), mm) !=
  863. CPU_CONTEXT(smp_processor_id(), current->mm)) {
  864. r4k_flush_cache_all_s128d16i16();
  865. } else {
  866. pgd_t *pgd;
  867. pmd_t *pmd;
  868. pte_t *pte;
  870. while(start < end) {
  871. pgd = pgd_offset(mm, start);
  872. pmd = pmd_offset(pgd, start);
  873. pte = pte_offset(pmd, start);
  875. if(pte_val(*pte) & _PAGE_VALID)
  876. blast_scache128_page(start);
  877. start += PAGE_SIZE;
  878. }
  879. }
  880. }
  881. }
  883. static void r4k_flush_cache_range_s32d32i32(struct mm_struct *mm,
  884.     unsigned long start,
  885.     unsigned long end)
  886. {
  887. struct vm_area_struct *vma;
  889. if (CPU_CONTEXT(smp_processor_id(), mm) == 0)
  890. return;
  892. start &= PAGE_MASK;
  893. #ifdef DEBUG_CACHE
  894. printk("crange[%d,%08lx,%08lx]", (int)mm->context, start, end);
  895. #endif
  896. vma = find_vma(mm, start);
  897. if(vma) {
  898. if (CPU_CONTEXT(smp_processor_id(), mm) !=
  899. CPU_CONTEXT(smp_processor_id(), current->mm)) {
  900. r4k_flush_cache_all_s32d32i32();
  901. } else {
  902. pgd_t *pgd;
  903. pmd_t *pmd;
  904. pte_t *pte;
  906. while(start < end) {
  907. pgd = pgd_offset(mm, start);
  908. pmd = pmd_offset(pgd, start);
  909. pte = pte_offset(pmd, start);
  911. if(pte_val(*pte) & _PAGE_VALID)
  912. blast_scache32_page(start);
  913. start += PAGE_SIZE;
  914. }
  915. }
  916. }
  917. }
  919. static void r4k_flush_cache_range_s64d32i32(struct mm_struct *mm,
  920.     unsigned long start,
  921.     unsigned long end)
  922. {
  923. struct vm_area_struct *vma;
  925. if (CPU_CONTEXT(smp_processor_id(), mm) == 0)
  926. return;
  928. start &= PAGE_MASK;
  929. #ifdef DEBUG_CACHE
  930. printk("crange[%d,%08lx,%08lx]", (int)mm->context, start, end);
  931. #endif
  932. vma = find_vma(mm, start);
  933. if(vma) {
  934. if (CPU_CONTEXT(smp_processor_id(), mm) !=
  935. CPU_CONTEXT(smp_processor_id(), current->mm)) {
  936. r4k_flush_cache_all_s64d32i32();
  937. } else {
  938. pgd_t *pgd;
  939. pmd_t *pmd;
  940. pte_t *pte;
  942. while(start < end) {
  943. pgd = pgd_offset(mm, start);
  944. pmd = pmd_offset(pgd, start);
  945. pte = pte_offset(pmd, start);
  947. if(pte_val(*pte) & _PAGE_VALID)
  948. blast_scache64_page(start);
  949. start += PAGE_SIZE;
  950. }
  951. }
  952. }
  953. }
  955. static void r4k_flush_cache_range_s128d32i32(struct mm_struct *mm,
  956.      unsigned long start,
  957.      unsigned long end)
  958. {
  959. struct vm_area_struct *vma;
  961. if (CPU_CONTEXT(smp_processor_id(), mm) != 0)
  962. return;
  964. start &= PAGE_MASK;
  965. #ifdef DEBUG_CACHE
  966. printk("crange[%d,%08lx,%08lx]", (int)mm->context, start, end);
  967. #endif
  968. vma = find_vma(mm, start);
  969. if(vma) {
  970. if (CPU_CONTEXT(smp_processor_id(), mm) !=
  971. CPU_CONTEXT(smp_processor_id(), current->mm)) {
  972. r4k_flush_cache_all_s128d32i32();
  973. } else {
  974. pgd_t *pgd;
  975. pmd_t *pmd;
  976. pte_t *pte;
  978. while(start < end) {
  979. pgd = pgd_offset(mm, start);
  980. pmd = pmd_offset(pgd, start);
  981. pte = pte_offset(pmd, start);
  983. if(pte_val(*pte) & _PAGE_VALID)
  984. blast_scache128_page(start);
  985. start += PAGE_SIZE;
  986. }
  987. }
  988. }
  989. }
  991. static void r4k_flush_cache_range_d16i16(struct mm_struct *mm,
  992.  unsigned long start,
  993.  unsigned long end)
  994. {
  995. if (CPU_CONTEXT(smp_processor_id(), mm) != 0) {
  996. #ifdef DEBUG_CACHE
  997. printk("crange[%d,%08lx,%08lx]", (int)mm->context, start, end);
  998. #endif
  999. blast_dcache16(); blast_icache16();
  1000. }
  1001. }
  1003. static void r4k_flush_cache_range_d32i32(struct mm_struct *mm,
  1004.  unsigned long start,
  1005.  unsigned long end)
  1006. {
  1007. if (CPU_CONTEXT(smp_processor_id(), mm) != 0) {
  1008. #ifdef DEBUG_CACHE
  1009. printk("crange[%d,%08lx,%08lx]", (int)mm->context, start, end);
  1010. #endif
  1011. blast_dcache32(); blast_icache32();
  1012. }
  1013. }
  1015. /*
  1016.  * On architectures like the Sparc, we could get rid of lines in
  1017.  * the cache created only by a certain context, but on the MIPS
  1018.  * (and actually certain Sparc's) we cannot.
  1019.  */
  1020. static void r4k_flush_cache_mm_s16d16i16(struct mm_struct *mm)
  1021. {
  1022. if (CPU_CONTEXT(smp_processor_id(), mm) != 0) {
  1023. #ifdef DEBUG_CACHE
  1024. printk("cmm[%d]", (int)mm->context);
  1025. #endif
  1026. r4k_flush_cache_all_s16d16i16();
  1027. }
  1028. }
  1030. static void r4k_flush_cache_mm_s32d16i16(struct mm_struct *mm)
  1031. {
  1032. if (CPU_CONTEXT(smp_processor_id(), mm) != 0) {
  1033. #ifdef DEBUG_CACHE
  1034. printk("cmm[%d]", (int)mm->context);
  1035. #endif
  1036. r4k_flush_cache_all_s32d16i16();
  1037. }
  1038. }
  1040. static void r4k_flush_cache_mm_s64d16i16(struct mm_struct *mm)
  1041. {
  1042. if (CPU_CONTEXT(smp_processor_id(), mm) != 0) {
  1043. #ifdef DEBUG_CACHE
  1044. printk("cmm[%d]", (int)mm->context);
  1045. #endif
  1046. r4k_flush_cache_all_s64d16i16();
  1047. }
  1048. }
  1050. static void r4k_flush_cache_mm_s128d16i16(struct mm_struct *mm)
  1051. {
  1052. if (CPU_CONTEXT(smp_processor_id(), mm) != 0) {
  1053. #ifdef DEBUG_CACHE
  1054. printk("cmm[%d]", (int)mm->context);
  1055. #endif
  1056. r4k_flush_cache_all_s128d16i16();
  1057. }
  1058. }
  1060. static void r4k_flush_cache_mm_s32d32i32(struct mm_struct *mm)
  1061. {
  1062. if (CPU_CONTEXT(smp_processor_id(), mm) != 0) {
  1063. #ifdef DEBUG_CACHE
  1064. printk("cmm[%d]", (int)mm->context);
  1065. #endif
  1066. r4k_flush_cache_all_s32d32i32();
  1067. }
  1068. }
  1070. static void r4k_flush_cache_mm_s64d32i32(struct mm_struct *mm)
  1071. {
  1072. if (CPU_CONTEXT(smp_processor_id(), mm) != 0) {
  1073. #ifdef DEBUG_CACHE
  1074. printk("cmm[%d]", (int)mm->context);
  1075. #endif
  1076. r4k_flush_cache_all_s64d32i32();
  1077. }
  1078. }
  1080. static void r4k_flush_cache_mm_s128d32i32(struct mm_struct *mm)
  1081. {
  1082. if (CPU_CONTEXT(smp_processor_id(), mm) != 0) {
  1083. #ifdef DEBUG_CACHE
  1084. printk("cmm[%d]", (int)mm->context);
  1085. #endif
  1086. r4k_flush_cache_all_s128d32i32();
  1087. }
  1088. }
  1090. static void r4k_flush_cache_mm_d16i16(struct mm_struct *mm)
  1091. {
  1092. if (CPU_CONTEXT(smp_processor_id(), mm) != 0) {
  1093. #ifdef DEBUG_CACHE
  1094. printk("cmm[%d]", (int)mm->context);
  1095. #endif
  1096. r4k_flush_cache_all_d16i16();
  1097. }
  1098. }
  1100. static void r4k_flush_cache_mm_d32i32(struct mm_struct *mm)
  1101. {
  1102. if (CPU_CONTEXT(smp_processor_id(), mm) != 0) {
  1103. #ifdef DEBUG_CACHE
  1104. printk("cmm[%d]", (int)mm->context);
  1105. #endif
  1106. r4k_flush_cache_all_d32i32();
  1107. }
  1108. }
  1110. static void r4k_flush_cache_page_s16d16i16(struct vm_area_struct *vma,
  1111.    unsigned long page)
  1112. {
  1113. struct mm_struct *mm = vma->vm_mm;
  1114. pgd_t *pgdp;
  1115. pmd_t *pmdp;
  1116. pte_t *ptep;
  1118. /*
  1119.  * If ownes no valid ASID yet, cannot possibly have gotten
  1120.  * this page into the cache.
  1121.  */
  1122. if (CPU_CONTEXT(smp_processor_id(), mm) == 0)
  1123. return;
  1125. #ifdef DEBUG_CACHE
  1126. printk("cpage[%d,%08lx]", (int)mm->context, page);
  1127. #endif
  1128. page &= PAGE_MASK;
  1129. pgdp = pgd_offset(mm, page);
  1130. pmdp = pmd_offset(pgdp, page);
  1131. ptep = pte_offset(pmdp, page);
  1133. /*
  1134.  * If the page isn't marked valid, the page cannot possibly be
  1135.  * in the cache.
  1136.  */
  1137. if(!(pte_val(*ptep) & _PAGE_VALID))
  1138. goto out;
  1140. /* Doing flushes for another ASID than the current one is
  1141.  * too difficult since stupid R4k caches do a TLB translation
  1142.  * for every cache flush operation.  So we do indexed flushes
  1143.  * in that case, which doesn't overly flush the cache too much.
  1144.  */
  1145. if (CPU_CONTEXT(smp_processor_id(), mm) !=
  1146.     CPU_CONTEXT(smp_processor_id(), current->mm)) {
  1147. /* Do indexed flush, too much work to get the (possible)
  1148.  * tlb refills to work correctly.
  1149.  */
  1150. page = (KSEG0 + (page & (scache_size - 1)));
  1151. blast_dcache16_page_indexed(page);
  1152. blast_scache16_page_indexed(page);
  1153. } else
  1154. blast_scache16_page(page);
  1155. out:
  1156. }
  1158. static void r4k_flush_cache_page_s32d16i16(struct vm_area_struct *vma,
  1159.    unsigned long page)
  1160. {
  1161. struct mm_struct *mm = vma->vm_mm;
  1162. pgd_t *pgdp;
  1163. pmd_t *pmdp;
  1164. pte_t *ptep;
  1166. /*
  1167.  * If ownes no valid ASID yet, cannot possibly have gotten
  1168.  * this page into the cache.
  1169.  */
  1170. if (CPU_CONTEXT(smp_processor_id(), mm) == 0)
  1171. return;
  1173. #ifdef DEBUG_CACHE
  1174. printk("cpage[%d,%08lx]", (int)mm->context, page);
  1175. #endif
  1176. page &= PAGE_MASK;
  1177. pgdp = pgd_offset(mm, page);
  1178. pmdp = pmd_offset(pgdp, page);
  1179. ptep = pte_offset(pmdp, page);
  1181. /* If the page isn't marked valid, the page cannot possibly be
  1182.  * in the cache.
  1183.  */
  1184. if(!(pte_val(*ptep) & _PAGE_VALID))
  1185. goto out;
  1187. /* Doing flushes for another ASID than the current one is
  1188.  * too difficult since stupid R4k caches do a TLB translation
  1189.  * for every cache flush operation.  So we do indexed flushes
  1190.  * in that case, which doesn't overly flush the cache too much.
  1191.  */
  1192. if (CPU_CONTEXT(smp_processor_id(), mm) !=
  1193.     CPU_CONTEXT(smp_processor_id(), current->mm)) {
  1194. /* Do indexed flush, too much work to get the (possible)
  1195.  * tlb refills to work correctly.
  1196.  */
  1197. page = (KSEG0 + (page & (scache_size - 1)));
  1198. blast_dcache16_page_indexed(page);
  1199. blast_scache32_page_indexed(page);
  1200. } else
  1201. blast_scache32_page(page);
  1202. out:
  1203. }
  1205. static void r4k_flush_cache_page_s64d16i16(struct vm_area_struct *vma,
  1206.    unsigned long page)
  1207. {
  1208. struct mm_struct *mm = vma->vm_mm;
  1209. pgd_t *pgdp;
  1210. pmd_t *pmdp;
  1211. pte_t *ptep;
  1213. /*
  1214.  * If ownes no valid ASID yet, cannot possibly have gotten
  1215.  * this page into the cache.
  1216.  */
  1217. if (CPU_CONTEXT(smp_processor_id(), mm) == 0)
  1218. return;
  1220. #ifdef DEBUG_CACHE
  1221. printk("cpage[%d,%08lx]", (int)mm->context, page);
  1222. #endif
  1223. page &= PAGE_MASK;
  1224. pgdp = pgd_offset(mm, page);
  1225. pmdp = pmd_offset(pgdp, page);
  1226. ptep = pte_offset(pmdp, page);
  1228. /* If the page isn't marked valid, the page cannot possibly be
  1229.  * in the cache.
  1230.  */
  1231. if(!(pte_val(*ptep) & _PAGE_VALID))
  1232. goto out;
  1234. /*
  1235.  * Doing flushes for another ASID than the current one is
  1236.  * too difficult since stupid R4k caches do a TLB translation
  1237.  * for every cache flush operation.  So we do indexed flushes
  1238.  * in that case, which doesn't overly flush the cache too much.
  1239.  */
  1240. if (CPU_CONTEXT(smp_processor_id(), mm) !=
  1241.     CPU_CONTEXT(smp_processor_id(), current->mm)) {
  1242. /* Do indexed flush, too much work to get the (possible)
  1243.  * tlb refills to work correctly.
  1244.  */
  1245. page = (KSEG0 + (page & (scache_size - 1)));
  1246. blast_dcache16_page_indexed(page);
  1247. blast_scache64_page_indexed(page);
  1248. } else
  1249. blast_scache64_page(page);
  1250. out:
  1251. }
  1253. static void r4k_flush_cache_page_s128d16i16(struct vm_area_struct *vma,
  1254.     unsigned long page)
  1255. {
  1256. struct mm_struct *mm = vma->vm_mm;
  1257. pgd_t *pgdp;
  1258. pmd_t *pmdp;
  1259. pte_t *ptep;
  1261. /*
  1262.  * If ownes no valid ASID yet, cannot possibly have gotten
  1263.  * this page into the cache.
  1264.  */
  1265. if (CPU_CONTEXT(smp_processor_id(), mm) == 0)
  1266. return;
  1268. #ifdef DEBUG_CACHE
  1269. printk("cpage[%d,%08lx]", (int)mm->context, page);
  1270. #endif
  1271. page &= PAGE_MASK;
  1272. pgdp = pgd_offset(mm, page);
  1273. pmdp = pmd_offset(pgdp, page);
  1274. ptep = pte_offset(pmdp, page);
  1276. /*
  1277.  * If the page isn't marked valid, the page cannot possibly be
  1278.  * in the cache.
  1279.  */
  1280. if(!(pte_val(*ptep) & _PAGE_VALID))
  1281. goto out;
  1283. /* Doing flushes for another ASID than the current one is
  1284.  * too difficult since stupid R4k caches do a TLB translation
  1285.  * for every cache flush operation.  So we do indexed flushes
  1286.  * in that case, which doesn't overly flush the cache too much.
  1287.  */
  1288. if (CPU_CONTEXT(smp_processor_id(), mm) !=
  1289.     CPU_CONTEXT(smp_processor_id(), current->mm)) {
  1290. /*
  1291.  * Do indexed flush, too much work to get the (possible)
  1292.  * tlb refills to work correctly.
  1293.  */
  1294. page = (KSEG0 + (page & (scache_size - 1)));
  1295. blast_dcache16_page_indexed(page);
  1296. blast_scache128_page_indexed(page);
  1297. } else
  1298. blast_scache128_page(page);
  1299. out:
  1300. }
  1302. static void r4k_flush_cache_page_s32d32i32(struct vm_area_struct *vma,
  1303.    unsigned long page)
  1304. {
  1305. struct mm_struct *mm = vma->vm_mm;
  1306. pgd_t *pgdp;
  1307. pmd_t *pmdp;
  1308. pte_t *ptep;
  1310. /*
  1311.  * If ownes no valid ASID yet, cannot possibly have gotten
  1312.  * this page into the cache.
  1313.  */
  1314. if (CPU_CONTEXT(smp_processor_id(), mm) == 0)
  1315. return;
  1317. #ifdef DEBUG_CACHE
  1318. printk("cpage[%d,%08lx]", (int)mm->context, page);
  1319. #endif
  1320. page &= PAGE_MASK;
  1321. pgdp = pgd_offset(mm, page);
  1322. pmdp = pmd_offset(pgdp, page);
  1323. ptep = pte_offset(pmdp, page);
  1325. /*
  1326.  * If the page isn't marked valid, the page cannot possibly be
  1327.  * in the cache.
  1328.  */
  1329. if(!(pte_val(*ptep) & _PAGE_VALID))
  1330. goto out;
  1332. /*
  1333.  * Doing flushes for another ASID than the current one is
  1334.  * too difficult since stupid R4k caches do a TLB translation
  1335.  * for every cache flush operation.  So we do indexed flushes
  1336.  * in that case, which doesn't overly flush the cache too much.
  1337.  */
  1338. if (CPU_CONTEXT(smp_processor_id(), mm) !=
  1339.     CPU_CONTEXT(smp_processor_id(), current->mm)) {
  1340. /*
  1341.  * Do indexed flush, too much work to get the (possible)
  1342.  * tlb refills to work correctly.
  1343.  */
  1344. page = (KSEG0 + (page & (scache_size - 1)));
  1345. blast_dcache32_page_indexed(page);
  1346. blast_scache32_page_indexed(page);
  1347. } else
  1348. blast_scache32_page(page);
  1349. out:
  1350. }
  1352. static void r4k_flush_cache_page_s64d32i32(struct vm_area_struct *vma,
  1353.    unsigned long page)
  1354. {
  1355. struct mm_struct *mm = vma->vm_mm;
  1356. pgd_t *pgdp;
  1357. pmd_t *pmdp;
  1358. pte_t *ptep;
  1360. /*
  1361.  * If ownes no valid ASID yet, cannot possibly have gotten
  1362.  * this page into the cache.
  1363.  */
  1364. if (CPU_CONTEXT(smp_processor_id(), mm) == 0)
  1365. return;
  1367. #ifdef DEBUG_CACHE
  1368. printk("cpage[%d,%08lx]", (int)mm->context, page);
  1369. #endif
  1370. page &= PAGE_MASK;
  1371. pgdp = pgd_offset(mm, page);
  1372. pmdp = pmd_offset(pgdp, page);
  1373. ptep = pte_offset(pmdp, page);
  1375. /*
  1376.  * If the page isn't marked valid, the page cannot possibly be
  1377.  * in the cache.
  1378.  */
  1379. if(!(pte_val(*ptep) & _PAGE_VALID))
  1380. goto out;
  1382. /*
  1383.  * Doing flushes for another ASID than the current one is
  1384.  * too difficult since stupid R4k caches do a TLB translation
  1385.  * for every cache flush operation.  So we do indexed flushes
  1386.  * in that case, which doesn't overly flush the cache too much.
  1387.  */
  1388. if (CPU_CONTEXT(smp_processor_id(), mm) !=
  1389.     CPU_CONTEXT(smp_processor_id(), current->mm)) {
  1390. /*
  1391.  * Do indexed flush, too much work to get the (possible)
  1392.  * tlb refills to work correctly.
  1393.  */
  1394. page = (KSEG0 + (page & (scache_size - 1)));
  1395. blast_dcache32_page_indexed(page);
  1396. blast_scache64_page_indexed(page);
  1397. } else
  1398. blast_scache64_page(page);
  1399. out:
  1400. }
  1402. static void r4k_flush_cache_page_s128d32i32(struct vm_area_struct *vma,
  1403.     unsigned long page)
  1404. {
  1405. struct mm_struct *mm = vma->vm_mm;
  1406. pgd_t *pgdp;
  1407. pmd_t *pmdp;
  1408. pte_t *ptep;
  1410. /*
  1411.  * If ownes no valid ASID yet, cannot possibly have gotten
  1412.  * this page into the cache.
  1413.  */
  1414. if (CPU_CONTEXT(smp_processor_id(), mm) == 0)
  1415. return;
  1417. #ifdef DEBUG_CACHE
  1418. printk("cpage[%d,%08lx]", (int)mm->context, page);
  1419. #endif
  1420. page &= PAGE_MASK;
  1421. pgdp = pgd_offset(mm, page);
  1422. pmdp = pmd_offset(pgdp, page);
  1423. ptep = pte_offset(pmdp, page);
  1425. /* If the page isn't marked valid, the page cannot possibly be
  1426.  * in the cache.
  1427.  */
  1428. if(!(pte_val(*ptep) & _PAGE_VALID))
  1429. goto out;
  1431. /*
  1432.  * Doing flushes for another ASID than the current one is
  1433.  * too difficult since stupid R4k caches do a TLB translation
  1434.  * for every cache flush operation.  So we do indexed flushes
  1435.  * in that case, which doesn't overly flush the cache too much.
  1436.  */
  1437. if (CPU_CONTEXT(smp_processor_id(), mm) !=
  1438.     CPU_CONTEXT(smp_processor_id(), current->mm)) {
  1439. /* Do indexed flush, too much work to get the (possible)
  1440.  * tlb refills to work correctly.
  1441.  */
  1442. page = (KSEG0 + (page & (scache_size - 1)));
  1443. blast_dcache32_page_indexed(page);
  1444. blast_scache128_page_indexed(page);
  1445. } else
  1446. blast_scache128_page(page);
  1447. out:
  1448. }
  1450. static void r4k_flush_cache_page_d16i16(struct vm_area_struct *vma,
  1451. unsigned long page)
  1452. {
  1453. struct mm_struct *mm = vma->vm_mm;
  1454. pgd_t *pgdp;
  1455. pmd_t *pmdp;
  1456. pte_t *ptep;
  1458. /*
  1459.  * If ownes no valid ASID yet, cannot possibly have gotten
  1460.  * this page into the cache.
  1461.  */
  1462. if (CPU_CONTEXT(smp_processor_id(), mm) == 0)
  1463. return;
  1465. #ifdef DEBUG_CACHE
  1466. printk("cpage[%d,%08lx]", (int)mm->context, page);
  1467. #endif
  1468. page &= PAGE_MASK;
  1469. pgdp = pgd_offset(mm, page);
  1470. pmdp = pmd_offset(pgdp, page);
  1471. ptep = pte_offset(pmdp, page);
  1473. /* If the page isn't marked valid, the page cannot possibly be
  1474.  * in the cache.
  1475.  */
  1476. if(!(pte_val(*ptep) & _PAGE_VALID))
  1477. goto out;
  1479. /*
  1480.  * Doing flushes for another ASID than the current one is
  1481.  * too difficult since stupid R4k caches do a TLB translation
  1482.  * for every cache flush operation.  So we do indexed flushes
  1483.  * in that case, which doesn't overly flush the cache too much.
  1484.  */
  1485. if(mm == current->mm) {
  1486. blast_dcache16_page(page);
  1487. } else {
  1488. /* Do indexed flush, too much work to get the (possible)
  1489.  * tlb refills to work correctly.
  1490.  */
  1491. page = (KSEG0 + (page & (dcache_size - 1)));
  1492. blast_dcache16_page_indexed(page);
  1493. }
  1494. out:
  1495. }
  1497. static void r4k_flush_cache_page_d32i32(struct vm_area_struct *vma,
  1498. unsigned long page)
  1499. {
  1500. struct mm_struct *mm = vma->vm_mm;
  1501. pgd_t *pgdp;
  1502. pmd_t *pmdp;
  1503. pte_t *ptep;
  1505. /*
  1506.  * If ownes no valid ASID yet, cannot possibly have gotten
  1507.  * this page into the cache.
  1508.  */
  1509. if (CPU_CONTEXT(smp_processor_id(), mm) == 0)
  1510. return;
  1512. #ifdef DEBUG_CACHE
  1513. printk("cpage[%d,%08lx]", (int)mm->context, page);
  1514. #endif
  1515. page &= PAGE_MASK;
  1516. pgdp = pgd_offset(mm, page);
  1517. pmdp = pmd_offset(pgdp, page);
  1518. ptep = pte_offset(pmdp, page);
  1520. /*
  1521.  * If the page isn't marked valid, the page cannot possibly be
  1522.  * in the cache.
  1523.  */
  1524. if(!(pte_val(*ptep) & _PAGE_PRESENT))
  1525. goto out;
  1527. /*
  1528.  * Doing flushes for another ASID than the current one is
  1529.  * too difficult since stupid R4k caches do a TLB translation
  1530.  * for every cache flush operation.  So we do indexed flushes
  1531.  * in that case, which doesn't overly flush the cache too much.
  1532.  */
  1533. if((mm == current->mm) && (pte_val(*ptep) & _PAGE_VALID)) {
  1534. blast_dcache32_page(page);
  1535. } else {
  1536. /*
  1537.  * Do indexed flush, too much work to get the (possible)
  1538.  * tlb refills to work correctly.
  1539.  */
  1540. page = (KSEG0 + (page & (dcache_size - 1)));
  1541. blast_dcache32_page_indexed(page);
  1542. }
  1543. out:
  1544. }
  1546. static void r4k_flush_cache_page_d32i32_r4600(struct vm_area_struct *vma,
  1547.       unsigned long page)
  1548. {
  1549. struct mm_struct *mm = vma->vm_mm;
  1550. pgd_t *pgdp;
  1551. pmd_t *pmdp;
  1552. pte_t *ptep;
  1554. /*
  1555.  * If ownes no valid ASID yet, cannot possibly have gotten
  1556.  * this page into the cache.
  1557.  */
  1558. if (CPU_CONTEXT(smp_processor_id(), mm) == 0)
  1559. return;
  1561. #ifdef DEBUG_CACHE
  1562. printk("cpage[%d,%08lx]", (int)mm->context, page);
  1563. #endif
  1564. page &= PAGE_MASK;
  1565. pgdp = pgd_offset(mm, page);
  1566. pmdp = pmd_offset(pgdp, page);
  1567. ptep = pte_offset(pmdp, page);
  1569. /*
  1570.  * If the page isn't marked valid, the page cannot possibly be
  1571.  * in the cache.
  1572.  */
  1573. if(!(pte_val(*ptep) & _PAGE_PRESENT))
  1574. goto out;
  1576. /*
  1577.  * Doing flushes for another ASID than the current one is
  1578.  * too difficult since stupid R4k caches do a TLB translation
  1579.  * for every cache flush operation.  So we do indexed flushes
  1580.  * in that case, which doesn't overly flush the cache too much.
  1581.  */
  1582. if((mm == current->mm) && (pte_val(*ptep) & _PAGE_VALID)) {
  1583. blast_dcache32_page(page);
  1584. } else {
  1585. /* Do indexed flush, too much work to get the (possible)
  1586.  * tlb refills to work correctly.
  1587.  */
  1588. page = (KSEG0 + (page & (dcache_size - 1)));
  1589. blast_dcache32_page_indexed(page);
  1590. blast_dcache32_page_indexed(page ^ dcache_waybit);
  1591. }
  1592. out:
  1593. }
  1595. static void r4k_flush_page_to_ram_s16(struct page *page)
  1596. {
  1597. blast_scache16_page((unsigned long)page_address(page));
  1598. }
  1600. static void r4k_flush_page_to_ram_s32(struct page *page)
  1601. {
  1602. blast_scache32_page((unsigned long)page_address(page));
  1603. }
  1605. static void r4k_flush_page_to_ram_s64(struct page *page)
  1606. {
  1607. blast_scache64_page((unsigned long)page_address(page));
  1608. }
  1610. static void r4k_flush_page_to_ram_s128(struct page *page)
  1611. {
  1612. blast_scache128_page((unsigned long)page_address(page));
  1613. }
  1615. static void r4k_flush_page_to_ram_d16(struct page *page)
  1616. {
  1617. blast_dcache16_page((unsigned long)page_address(page));
  1618. }
  1620. static void r4k_flush_page_to_ram_d32(struct page *page)
  1621. {
  1622. blast_dcache32_page((unsigned long)page_address(page));
  1623. }
  1625. static void
  1626. r4k_flush_icache_range(unsigned long start, unsigned long end)
  1627. {
  1628. flush_cache_all();
  1629. }
  1631. static void
  1632. r4k_flush_icache_page_s(struct vm_area_struct *vma, struct page *page)
  1633. {
  1634. /*
  1635.  * We did an scache flush therefore PI is already clean.
  1636.  */
  1637. }
  1639. /*
  1640.  * Ok, this seriously sucks.  We use them to flush a user page but don't
  1641.  * know the virtual address, so we have to blast away the whole icache
  1642.  * which is significantly more expensive than the real thing.
  1643.  */
  1644. static void
  1645. r4k_flush_icache_page_p(struct vm_area_struct *vma, struct page *page)
  1646. {
  1647. if (!(vma->vm_flags & VM_EXEC))
  1648. return;
  1650. flush_cache_all();
  1651. }
  1653. /*
  1654.  * Writeback and invalidate the primary cache dcache before DMA.
  1655.  *
  1656.  * R4600 v2.0 bug: "The CACHE instructions Hit_Writeback_Inv_D,
  1657.  * Hit_Writeback_D, Hit_Invalidate_D and Create_Dirty_Exclusive_D will only
  1658.  * operate correctly if the internal data cache refill buffer is empty.  These
  1659.  * CACHE instructions should be separated from any potential data cache miss
  1660.  * by a load instruction to an uncached address to empty the response buffer."
  1661.  * (Revision 2.0 device errata from IDT available on http://www.idt.com/
  1662.  * in .pdf format.)
  1663.  */
  1664. static void r4k_dma_cache_wback_inv_pc(unsigned long addr, unsigned long size)
  1665. {
  1666. unsigned long end, a;
  1667. unsigned int flags;
  1669. if (size >= (unsigned long)dcache_size) {
  1670. flush_cache_l1();
  1671. } else {
  1672. /* Workaround for R4600 bug.  See comment above. */
  1673. __save_and_cli(flags);
  1674. *(volatile unsigned long *)KSEG1;
  1676. a = addr & ~((unsigned long)dc_lsize - 1);
  1677. end = (addr + size) & ~((unsigned long)dc_lsize - 1);
  1678. while (1) {
  1679. flush_dcache_line(a); /* Hit_Writeback_Inv_D */
  1680. if (a == end) break;
  1681. a += dc_lsize;
  1682. }
  1683. __restore_flags(flags);
  1684. }
  1685. bc_wback_inv(addr, size);
  1686. }
  1688. static void r4k_dma_cache_wback_inv_sc(unsigned long addr, unsigned long size)
  1689. {
  1690. unsigned long end, a;
  1692. if (size >= (unsigned long)scache_size) {
  1693. flush_cache_l1();
  1694. return;
  1695. }
  1697. a = addr & ~((unsigned long)sc_lsize - 1);
  1698. end = (addr + size) & ~((unsigned long)sc_lsize - 1);
  1699. while (1) {
  1700. flush_scache_line(a); /* Hit_Writeback_Inv_SD */
  1701. if (a == end) break;
  1702. a += sc_lsize;
  1703. }
  1704. }
  1706. static void r4k_dma_cache_inv_pc(unsigned long addr, unsigned long size)
  1707. {
  1708. unsigned long end, a;
  1709. unsigned int flags;
  1711. if (size >= (unsigned long)dcache_size) {
  1712. flush_cache_l1();
  1713. } else {
  1714. /* Workaround for R4600 bug.  See comment above. */
  1715. __save_and_cli(flags);
  1716. *(volatile unsigned long *)KSEG1;
  1718. a = addr & ~((unsigned long)dc_lsize - 1);
  1719. end = (addr + size) & ~((unsigned long)dc_lsize - 1);
  1720. while (1) {
  1721. flush_dcache_line(a); /* Hit_Writeback_Inv_D */
  1722. if (a == end) break;
  1723. a += dc_lsize;
  1724. }
  1725. __restore_flags(flags);
  1726. }
  1728. bc_inv(addr, size);
  1729. }
  1731. static void r4k_dma_cache_inv_sc(unsigned long addr, unsigned long size)
  1732. {
  1733. unsigned long end, a;
  1735. if (size >= (unsigned long)scache_size) {
  1736. flush_cache_l1();
  1737. return;
  1738. }
  1740. a = addr & ~((unsigned long)sc_lsize - 1);
  1741. end = (addr + size) & ~((unsigned long)sc_lsize - 1);
  1742. while (1) {
  1743. flush_scache_line(a); /* Hit_Writeback_Inv_SD */
  1744. if (a == end) break;
  1745. a += sc_lsize;
  1746. }
  1747. }
  1749. /*
  1750.  * While we're protected against bad userland addresses we don't care
  1751.  * very much about what happens in that case.  Usually a segmentation
  1752.  * fault will dump the process later on anyway ...
  1753.  */
  1754. static void r4k_flush_cache_sigtramp(unsigned long addr)
  1755. {
  1756. __asm__ __volatile__("nop;nop;nop;nop"); /* R4600 V1.7 */
  1758. protected_writeback_dcache_line(addr & ~(dc_lsize - 1));
  1759. protected_flush_icache_line(addr & ~(ic_lsize - 1));
  1760. }
  1762. static void r4600v20k_flush_cache_sigtramp(unsigned long addr)
  1763. {
  1764. unsigned int flags;
  1766. __save_and_cli(flags);
  1768. /* Clear internal cache refill buffer */
  1769. *(volatile unsigned int *)KSEG1;
  1771. protected_writeback_dcache_line(addr & ~(dc_lsize - 1));
  1772. protected_flush_icache_line(addr & ~(ic_lsize - 1));
  1774. __restore_flags(flags);
  1775. }
  1777. #undef DEBUG_TLB
  1779. #define NTLB_ENTRIES       48  /* Fixed on all R4XX0 variants... */
  1781. #define NTLB_ENTRIES_HALF  24  /* Fixed on all R4XX0 variants... */
  1783. void local_flush_tlb_all(void)
  1784. {
  1785. unsigned long flags;
  1786. unsigned long old_ctx;
  1787. int entry;
  1789. #ifdef DEBUG_TLB
  1790. printk("[tlball]");
  1791. #endif
  1793. __save_and_cli(flags);
  1794. /* Save old context and create impossible VPN2 value */
  1795. old_ctx = (get_entryhi() & 0xff);
  1796. set_entryhi(KSEG0);
  1797. set_entrylo0(0);
  1798. set_entrylo1(0);
  1799. BARRIER;
  1801. entry = get_wired();
  1803. /* Blast 'em all away. */
  1804. while(entry < NTLB_ENTRIES) {
  1805. set_index(entry);
  1806. BARRIER;
  1807. tlb_write_indexed();
  1808. BARRIER;
  1809. entry++;
  1810. }
  1811. BARRIER;
  1812. set_entryhi(old_ctx);
  1813. __restore_flags(flags);
  1814. }
  1816. void local_flush_tlb_mm(struct mm_struct *mm)
  1817. {
  1818. if (CPU_CONTEXT(smp_processor_id(), mm) != 0) {
  1819. unsigned long flags;
  1821. #ifdef DEBUG_TLB
  1822. printk("[tlbmm<%d>]", mm->context);
  1823. #endif
  1824. __save_and_cli(flags);
  1825. get_new_mmu_context(mm, smp_processor_id());
  1826. if(mm == current->mm)
  1827. set_entryhi(CPU_CONTEXT(smp_processor_id(), mm) & 0xff);
  1828. __restore_flags(flags);
  1829. }
  1830. }
  1832. void local_flush_tlb_range(struct mm_struct *mm, unsigned long start,
  1833. unsigned long end)
  1834. {
  1835. if (CPU_CONTEXT(smp_processor_id(), mm) != 0) {
  1836. unsigned long flags;
  1837. int size;
  1839. #ifdef DEBUG_TLB
  1840. printk("[tlbrange<%02x,%08lx,%08lx>]", (mm->context & 0xff),
  1841.        start, end);
  1842. #endif
  1843. __save_and_cli(flags);
  1844. size = (end - start + (PAGE_SIZE - 1)) >> PAGE_SHIFT;
  1845. size = (size + 1) >> 1;
  1846. if(size <= NTLB_ENTRIES_HALF) {
  1847. int oldpid = (get_entryhi() & 0xff);
  1848. int newpid = (CPU_CONTEXT(smp_processor_id(), mm) & 0xff);
  1850. start &= (PAGE_MASK << 1);
  1851. end += ((PAGE_SIZE << 1) - 1);
  1852. end &= (PAGE_MASK << 1);
  1853. while(start < end) {
  1854. int idx;
  1856. set_entryhi(start | newpid);
  1857. start += (PAGE_SIZE << 1);
  1858. BARRIER;
  1859. tlb_probe();
  1860. BARRIER;
  1861. idx = get_index();
  1862. set_entrylo0(0);
  1863. set_entrylo1(0);
  1864. set_entryhi(KSEG0);
  1865. BARRIER;
  1866. if(idx < 0)
  1867. continue;
  1868. tlb_write_indexed();
  1869. BARRIER;
  1870. }
  1871. set_entryhi(oldpid);
  1872. } else {
  1873. get_new_mmu_context(mm, smp_processor_id());
  1874. if(mm == current->mm)
  1875. set_entryhi(CPU_CONTEXT(smp_processor_id(),
  1876. mm) & 0xff);
  1877. }
  1878. __restore_flags(flags);
  1879. }
  1880. }
  1882. void local_flush_tlb_page(struct vm_area_struct *vma, unsigned long page)
  1883. {
  1884. if (CPU_CONTEXT(smp_processor_id(), vma->vm_mm) != 0) {
  1885. unsigned long flags;
  1886. int oldpid, newpid, idx;
  1888. #ifdef DEBUG_TLB
  1889. printk("[tlbpage<%d,%08lx>]", vma->vm_mm->context, page);
  1890. #endif
  1891. newpid = (CPU_CONTEXT(smp_processor_id(), vma->vm_mm) & 0xff);
  1892. page &= (PAGE_MASK << 1);
  1893. __save_and_cli(flags);
  1894. oldpid = (get_entryhi() & 0xff);
  1895. set_entryhi(page | newpid);
  1896. BARRIER;
  1897. tlb_probe();
  1898. BARRIER;
  1899. idx = get_index();
  1900. set_entrylo0(0);
  1901. set_entrylo1(0);
  1902. set_entryhi(KSEG0);
  1903. if(idx < 0)
  1904. goto finish;
  1905. BARRIER;
  1906. tlb_write_indexed();
  1908. finish:
  1909. BARRIER;
  1910. set_entryhi(oldpid);
  1911. __restore_flags(flags);
  1912. }
  1913. }
  1915. static void r4k_flush_cache_l2(void)
  1916. {
  1917. }
  1919. /* We will need multiple versions of update_mmu_cache(), one that just
  1920.  * updates the TLB with the new pte(s), and another which also checks
  1921.  * for the R4k "end of page" hardware bug and does the needy.
  1922.  */
  1923. static void r4k_update_mmu_cache(struct vm_area_struct * vma,
  1924.  unsigned long address, pte_t pte)
  1925. {
  1926. unsigned long flags;
  1927. pgd_t *pgdp;
  1928. pmd_t *pmdp;
  1929. pte_t *ptep;
  1930. int idx, pid;
  1932. /*
  1933.  * Handle debugger faulting in for debugee.
  1934.  */
  1935. if (current->active_mm != vma->vm_mm)
  1936. return;
  1938. __save_and_cli(flags);
  1939. pid = (get_entryhi() & 0xff);
  1941. #ifdef DEBUG_TLB
  1942. if((pid != (CPU_CONTEXT(smp_processor_id(), vma->vm_mm) & 0xff)) ||
  1943.    (CPU_CONTEXT(smp_processor_id(), vma->vm_mm) == 0)) {
  1944. printk("update_mmu_cache: Wheee, bogus tlbpid mmpid=%d
  1945. tlbpid=%dn", (int) (CPU_CONTEXT(smp_processor_id(),
  1946. vma->vm_mm) & 0xff), pid);
  1947. }
  1948. #endif
  1950. address &= (PAGE_MASK << 1);
  1951. set_entryhi(address | (pid));
  1952. pgdp = pgd_offset(vma->vm_mm, address);
  1953. BARRIER;
  1954. tlb_probe();
  1955. BARRIER;
  1956. pmdp = pmd_offset(pgdp, address);
  1957. idx = get_index();
  1958. ptep = pte_offset(pmdp, address);
  1959. BARRIER;
  1960. set_entrylo0(pte_val(*ptep++) >> 6);
  1961. set_entrylo1(pte_val(*ptep) >> 6);
  1962. set_entryhi(address | (pid));
  1963. BARRIER;
  1964. if(idx < 0) {
  1965. tlb_write_random();
  1966. } else {
  1967. tlb_write_indexed();
  1968. }
  1969. BARRIER;
  1970. set_entryhi(pid);
  1971. BARRIER;
  1972. __restore_flags(flags);
  1973. }
  1975. #if 0
  1976. static void r4k_update_mmu_cache_hwbug(struct vm_area_struct * vma,
  1977.        unsigned long address, pte_t pte)
  1978. {
  1979. unsigned long flags;
  1980. pgd_t *pgdp;
  1981. pmd_t *pmdp;
  1982. pte_t *ptep;
  1983. int idx;
  1985. __save_and_cli(flags);
  1986. address &= (PAGE_MASK << 1);
  1987. set_entryhi(address | (get_entryhi() & 0xff));
  1988. pgdp = pgd_offset(vma->vm_mm, address);
  1989. tlb_probe();
  1990. pmdp = pmd_offset(pgdp, address);
  1991. idx = get_index();
  1992. ptep = pte_offset(pmdp, address);
  1993. set_entrylo0(pte_val(*ptep++) >> 6);
  1994. set_entrylo1(pte_val(*ptep) >> 6);
  1995. BARRIER;
  1996. if(idx < 0)
  1997. tlb_write_random();
  1998. else
  1999. tlb_write_indexed();
  2000. BARRIER;
  2001. __restore_flags(flags);
  2002. }
  2003. #endif
  2005. /* Detect and size the various r4k caches. */
  2006. static void __init probe_icache(unsigned long config)
  2007. {
  2008. icache_size = 1 << (12 + ((config >> 9) & 7));
  2009. ic_lsize = 16 << ((config >> 5) & 1);
  2011. printk("Primary instruction cache %dkb, linesize %d bytes)n",
  2012.        icache_size >> 10, ic_lsize);
  2013. }
  2015. static void __init probe_dcache(unsigned long config)
  2016. {
  2017. dcache_size = 1 << (12 + ((config >> 6) & 7));
  2018. dc_lsize = 16 << ((config >> 4) & 1);
  2020. printk("Primary data cache %dkb, linesize %d bytes)n",
  2021.        dcache_size >> 10, dc_lsize);
  2022. }
  2025. /* If you even _breathe_ on this function, look at the gcc output
  2026.  * and make sure it does not pop things on and off the stack for
  2027.  * the cache sizing loop that executes in KSEG1 space or else
  2028.  * you will crash and burn badly.  You have been warned.
  2029.  */
  2030. static int __init probe_scache(unsigned long config)
  2031. {
  2032. extern unsigned long stext;
  2033. unsigned long flags, addr, begin, end, pow2;
  2034. int tmp;
  2036. tmp = ((config >> 17) & 1);
  2037. if(tmp)
  2038. return 0;
  2039. tmp = ((config >> 22) & 3);
  2040. switch(tmp) {
  2041. case 0:
  2042. sc_lsize = 16;
  2043. break;
  2044. case 1:
  2045. sc_lsize = 32;
  2046. break;
  2047. case 2:
  2048. sc_lsize = 64;
  2049. break;
  2050. case 3:
  2051. sc_lsize = 128;
  2052. break;
  2053. }
  2055. begin = (unsigned long) &stext;
  2056. begin &= ~((4 * 1024 * 1024) - 1);
  2057. end = begin + (4 * 1024 * 1024);
  2059. /* This is such a bitch, you'd think they would make it
  2060.  * easy to do this.  Away you daemons of stupidity!
  2061.  */
  2062. __save_and_cli(flags);
  2064. /* Fill each size-multiple cache line with a valid tag. */
  2065. pow2 = (64 * 1024);
  2066. for(addr = begin; addr < end; addr = (begin + pow2)) {
  2067. unsigned long *p = (unsigned long *) addr;
  2068. __asm__ __volatile__("nop" : : "r" (*p)); /* whee... */
  2069. pow2 <<= 1;
  2070. }
  2072. /* Load first line with zero (therefore invalid) tag. */
  2073. set_taglo(0);
  2074. set_taghi(0);
  2075. __asm__ __volatile__("nop; nop; nop; nop;"); /* avoid the hazard */
  2076. __asm__ __volatile__("nt.set noreordernt"
  2077.      "cache 8, (%0)nt"
  2078.      ".set reordernt" : : "r" (begin));
  2079. __asm__ __volatile__("nt.set noreordernt"
  2080.      "cache 9, (%0)nt"
  2081.      ".set reordernt" : : "r" (begin));
  2082. __asm__ __volatile__("nt.set noreordernt"
  2083.      "cache 11, (%0)nt"
  2084.      ".set reordernt" : : "r" (begin));
  2086. /* Now search for the wrap around point. */
  2087. pow2 = (128 * 1024);
  2088. tmp = 0;
  2089. for(addr = (begin + (128 * 1024)); addr < (end); addr = (begin + pow2)) {
  2090. __asm__ __volatile__("nt.set noreordernt"
  2091.      "cache 7, (%0)nt"
  2092.      ".set reordernt" : : "r" (addr));
  2093. __asm__ __volatile__("nop; nop; nop; nop;"); /* hazard... */
  2094. if(!get_taglo())
  2095. break;
  2096. pow2 <<= 1;
  2097. }
  2098. __restore_flags(flags);
  2099. addr -= begin;
  2100. printk("Secondary cache sized at %dK linesize %dn",
  2101.        (int) (addr >> 10), sc_lsize);
  2102. scache_size = addr;
  2103. return 1;
  2104. }
  2106. static void __init setup_noscache_funcs(void)
  2107. {
  2108. unsigned int prid;
  2110. switch(dc_lsize) {
  2111. case 16:
  2112. _clear_page = r4k_clear_page_d16;
  2113. _copy_page = r4k_copy_page_d16;
  2114. _flush_cache_all = r4k_flush_cache_all_d16i16;
  2115. _flush_cache_l1 = r4k_flush_cache_all_d16i16;
  2116. _flush_cache_mm = r4k_flush_cache_mm_d16i16;
  2117. _flush_cache_range = r4k_flush_cache_range_d16i16;
  2118. _flush_cache_page = r4k_flush_cache_page_d16i16;
  2119. break;
  2120. case 32:
  2121. prid = read_32bit_cp0_register(CP0_PRID) & 0xfff0;
  2122. if (prid == 0x2010) { /* R4600 V1.7 */
  2123. _clear_page = r4k_clear_page_r4600_v1;
  2124. _copy_page = r4k_copy_page_r4600_v1;
  2125. } else if (prid == 0x2020) { /* R4600 V2.0 */
  2126. _clear_page = r4k_clear_page_r4600_v2;
  2127. _copy_page = r4k_copy_page_r4600_v2;
  2128. } else {
  2129. _clear_page = r4k_clear_page_d32;
  2130. _copy_page = r4k_copy_page_d32;
  2131. }
  2132. _flush_cache_all = r4k_flush_cache_all_d32i32;
  2133. _flush_cache_l1 = r4k_flush_cache_all_d32i32;
  2134. _flush_cache_mm = r4k_flush_cache_mm_d32i32;
  2135. _flush_cache_range = r4k_flush_cache_range_d32i32;
  2136. _flush_cache_page = r4k_flush_cache_page_d32i32;
  2137. break;
  2138. }
  2140. switch(ic_lsize) {
  2141. case 16:
  2142. _flush_page_to_ram = r4k_flush_page_to_ram_d16;
  2143. break;
  2144. case 32:
  2145. _flush_page_to_ram = r4k_flush_page_to_ram_d32;
  2146. break;
  2147. }
  2148. _flush_icache_page = r4k_flush_icache_page_p;
  2149. _dma_cache_wback_inv = r4k_dma_cache_wback_inv_pc;
  2150. _dma_cache_wback = r4k_dma_cache_wback_inv_pc;
  2151. _dma_cache_inv = r4k_dma_cache_inv_pc;
  2152. }
  2154. static void __init setup_scache_funcs(void)
  2155. {
  2156. switch(sc_lsize) {
  2157. case 16:
  2158. switch(dc_lsize) {
  2159. case 16:
  2160. _flush_cache_all = r4k_flush_cache_all_s16d16i16;
  2161. _flush_cache_l1 = r4k_flush_cache_all_s16d16i16;
  2162. _flush_cache_mm = r4k_flush_cache_mm_s16d16i16;
  2163. _flush_cache_range = r4k_flush_cache_range_s16d16i16;
  2164. _flush_cache_page = r4k_flush_cache_page_s16d16i16;
  2165. break;
  2166. case 32:
  2167. panic("Invalid cache configuration detected");
  2168. };
  2169. _flush_page_to_ram = r4k_flush_page_to_ram_s16;
  2170. _clear_page = r4k_clear_page_s16;
  2171. _copy_page = r4k_copy_page_s16;
  2172. break;
  2173. case 32:
  2174. switch(dc_lsize) {
  2175. case 16:
  2176. _flush_cache_all = r4k_flush_cache_all_s32d16i16;
  2177. _flush_cache_l1 = r4k_flush_cache_all_s32d16i16;
  2178. _flush_cache_mm = r4k_flush_cache_mm_s32d16i16;
  2179. _flush_cache_range = r4k_flush_cache_range_s32d16i16;
  2180. _flush_cache_page = r4k_flush_cache_page_s32d16i16;
  2181. break;
  2182. case 32:
  2183. _flush_cache_all = r4k_flush_cache_all_s32d32i32;
  2184. _flush_cache_l1 = r4k_flush_cache_all_s32d32i32;
  2185. _flush_cache_mm = r4k_flush_cache_mm_s32d32i32;
  2186. _flush_cache_range = r4k_flush_cache_range_s32d32i32;
  2187. _flush_cache_page = r4k_flush_cache_page_s32d32i32;
  2188. break;
  2189. };
  2190. _flush_page_to_ram = r4k_flush_page_to_ram_s32;
  2191. _clear_page = r4k_clear_page_s32;
  2192. _copy_page = r4k_copy_page_s32;
  2193. break;
  2194. case 64:
  2195. switch(dc_lsize) {
  2196. case 16:
  2197. _flush_cache_all = r4k_flush_cache_all_s64d16i16;
  2198. _flush_cache_l1 = r4k_flush_cache_all_s64d16i16;
  2199. _flush_cache_mm = r4k_flush_cache_mm_s64d16i16;
  2200. _flush_cache_range = r4k_flush_cache_range_s64d16i16;
  2201. _flush_cache_page = r4k_flush_cache_page_s64d16i16;
  2202. break;
  2203. case 32:
  2204. _flush_cache_all = r4k_flush_cache_all_s64d32i32;
  2205. _flush_cache_l1 = r4k_flush_cache_all_s64d32i32;
  2206. _flush_cache_mm = r4k_flush_cache_mm_s64d32i32;
  2207. _flush_cache_range = r4k_flush_cache_range_s64d32i32;
  2208. _flush_cache_page = r4k_flush_cache_page_s64d32i32;
  2209. break;
  2210. };
  2211. _flush_page_to_ram = r4k_flush_page_to_ram_s64;
  2212. _clear_page = r4k_clear_page_s64;
  2213. _copy_page = r4k_copy_page_s64;
  2214. break;
  2215. case 128:
  2216. switch(dc_lsize) {
  2217. case 16:
  2218. _flush_cache_all = r4k_flush_cache_all_s128d16i16;
  2219. _flush_cache_l1 = r4k_flush_cache_all_s128d16i16;
  2220. _flush_cache_mm = r4k_flush_cache_mm_s128d16i16;
  2221. _flush_cache_range = r4k_flush_cache_range_s128d16i16;
  2222. _flush_cache_page = r4k_flush_cache_page_s128d16i16;
  2223. break;
  2224. case 32:
  2225. _flush_cache_all = r4k_flush_cache_all_s128d32i32;
  2226. _flush_cache_l1 = r4k_flush_cache_all_s128d32i32;
  2227. _flush_cache_mm = r4k_flush_cache_mm_s128d32i32;
  2228. _flush_cache_range = r4k_flush_cache_range_s128d32i32;
  2229. _flush_cache_page = r4k_flush_cache_page_s128d32i32;
  2230. break;
  2231. };
  2232. _flush_page_to_ram = r4k_flush_page_to_ram_s128;
  2233. _clear_page = r4k_clear_page_s128;
  2234. _copy_page = r4k_copy_page_s128;
  2235. break;
  2236. }
  2237. _flush_icache_page = r4k_flush_icache_page_s;
  2238. _dma_cache_wback_inv = r4k_dma_cache_wback_inv_sc;
  2239. _dma_cache_wback = r4k_dma_cache_wback_inv_sc;
  2240. _dma_cache_inv = r4k_dma_cache_inv_sc;
  2241. }
  2243. typedef int (*probe_func_t)(unsigned long);
  2244. extern int r5k_sc_init(void);
  2246. static inline void __init setup_scache(unsigned int config)
  2247. {
  2248. probe_func_t probe_scache_kseg1;
  2249. int sc_present = 0;
  2251. /* Maybe the cpu knows about a l2 cache? */
  2252. probe_scache_kseg1 = (probe_func_t) (KSEG1ADDR(&probe_scache));
  2253. sc_present = probe_scache_kseg1(config);
  2255. if (!sc_present) {
  2256. setup_noscache_funcs();
  2257. return;
  2258. }
  2260. switch(mips_cpu.cputype) {
  2261. case CPU_R5000:
  2262. case CPU_NEVADA:
  2263. setup_noscache_funcs();
  2264. #if defined(CONFIG_CPU_R5000) || defined(CONFIG_CPU_NEVADA)
  2265. r5k_sc_init();
  2266. #endif
  2267. break;
  2268. default:
  2269. setup_scache_funcs();
  2270. }
  2272. }
  2274. void __init ld_mmu_r4xx0(void)
  2275. {
  2276. unsigned long config = read_32bit_cp0_register(CP0_CONFIG);
  2278. change_cp0_config(CONF_CM_CMASK | CONF_CU, CONF_CM_DEFAULT);
  2280. probe_icache(config);
  2281. probe_dcache(config);
  2282. setup_scache(config);
  2284. switch(mips_cpu.cputype) {
  2285. case CPU_R4600: /* QED style two way caches? */
  2286. case CPU_R4700:
  2287. case CPU_R5000:
  2288. case CPU_NEVADA:
  2289. _flush_cache_page = r4k_flush_cache_page_d32i32_r4600;
  2290. }
  2292. _flush_cache_sigtramp = r4k_flush_cache_sigtramp;
  2293. if ((read_32bit_cp0_register(CP0_PRID) & 0xfff0) == 0x2020) {
  2294. _flush_cache_sigtramp = r4600v20k_flush_cache_sigtramp;
  2295. }
  2296. _flush_icache_range = r4k_flush_icache_range; /* Ouch */
  2298. _flush_cache_l2 = r4k_flush_cache_l2;
  2300. _update_mmu_cache = r4k_update_mmu_cache;
  2302. flush_cache_l1();
  2304. /*
  2305.  * You should never change this register:
  2306.  *   - On R4600 1.7 the tlbp never hits for pages smaller than
  2307.  *     the value in the c0_pagemask register.
  2308.  *   - The entire mm handling assumes the c0_pagemask register to
  2309.  *     be set for 4kb pages.
  2310.  */
  2311. write_32bit_cp0_register(CP0_PAGEMASK, PM_4K);
  2312. local_flush_tlb_all();
  2313. }