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

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

Linux/Unix编程

开发平台：

Unix_Linux

c-sb1.c：源码内容
  1. /*
  2.  * Copyright (C) 1996 David S. Miller (dm@engr.sgi.com)
  3.  * Copyright (C) 1997, 2001 Ralf Baechle (ralf@gnu.org)
  4.  * Copyright (C) 2000, 2001 Broadcom Corporation
  5.  *
  6.  * This program is free software; you can redistribute it and/or
  7.  * modify it under the terms of the GNU General Public License
  8.  * as published by the Free Software Foundation; either version 2
  9.  * of the License, or (at your option) any later version.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program; if not, write to the Free Software
  18.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  19.  */
  20. #include <linux/config.h>
  21. #include <linux/init.h>
  22. #include <asm/mmu_context.h>
  23. #include <asm/bootinfo.h>
  24. #include <asm/cacheops.h>
  25. #include <asm/cpu.h>
  26. #include <asm/uaccess.h>
  28. /* These are probed at ld_mmu time */
  29. static unsigned int icache_size;
  30. static unsigned int dcache_size;
  32. static unsigned int icache_line_size;
  33. static unsigned int dcache_line_size;
  35. static unsigned int icache_index_mask;
  37. static unsigned int icache_assoc;
  38. static unsigned int dcache_assoc;
  40. static unsigned int icache_sets;
  41. static unsigned int dcache_sets;
  43. void pgd_init(unsigned long page)
  44. {
  45. unsigned long *p = (unsigned long *) page;
  46. int i;
  48. for (i = 0; i < USER_PTRS_PER_PGD; i+=8) {
  49. p[i + 0] = (unsigned long) invalid_pte_table;
  50. p[i + 1] = (unsigned long) invalid_pte_table;
  51. p[i + 2] = (unsigned long) invalid_pte_table;
  52. p[i + 3] = (unsigned long) invalid_pte_table;
  53. p[i + 4] = (unsigned long) invalid_pte_table;
  54. p[i + 5] = (unsigned long) invalid_pte_table;
  55. p[i + 6] = (unsigned long) invalid_pte_table;
  56. p[i + 7] = (unsigned long) invalid_pte_table;
  57. }
  58. }
  60. /*
  61.  * The dcache is fully coherent to the system, with one
  62.  * big caveat:  the instruction stream.  In other words,
  63.  * if we miss in the icache, and have dirty data in the
  64.  * L1 dcache, then we'll go out to memory (or the L2) and
  65.  * get the not-as-recent data.
  66.  *
  67.  * So the only time we have to flush the dcache is when
  68.  * we're flushing the icache.  Since the L2 is fully
  69.  * coherent to everything, including I/O, we never have
  70.  * to flush it
  71.  */
  73. static void sb1_flush_cache_all(void)
  74. {
  75. }
  77. static void local_sb1___flush_cache_all(void)
  78. {
  79. /*
  80.  * Haven't worried too much about speed here; given that we're flushing
  81.  * the icache, the time to invalidate is dwarfed by the time it's going
  82.  * to take to refill it.  Register usage:
  83.  *
  84.  * $1 - moving cache index
  85.  * $2 - set count
  86.  */
  87. __asm__ __volatile__ (
  88. ".set push                  n"
  89. ".set noreorder             n"
  90. ".set noat                  n"
  91. ".set mips4                 n"
  92. "     move   $1, %2         n" /* Start at index 0 */
  93. "1:   cache  %3, 0($1)      n" /* WB/Invalidate this index */
  94. "     addiu  %1, %1, -1     n" /* Decrement loop count */
  95. "     bnez   %1, 1b         n" /* loop test */
  96. "      addu   $1, $1, %0    n" /* Next address */
  97. ".set pop                   n"
  98. :
  99. : "r" (dcache_line_size), "r" (dcache_sets * dcache_assoc),
  100.   "r" (KSEG0), "i" (Index_Writeback_Inv_D));
  102. __asm__ __volatile__ (
  103. ".set push                  n"
  104. ".set noreorder             n"
  105. ".set mips2                 n"
  106. "sync                       n"
  107. #ifdef CONFIG_SB1_PASS_1_WORKAROUNDS /* Bug 1384 */
  108. "sync                       n"
  109. #endif
  110. ".set pop                   n");
  112. __asm__ __volatile__ (
  113. ".set push                  n"
  114. ".set noreorder             n"
  115. ".set noat                  n"
  116. ".set mips4                 n"
  117. "     move   $1, %2         n" /* Start at index 0 */
  118. "1:   cache  %3, 0($1)       n" /* Invalidate this index */
  119. "     addiu  %1, %1, -1     n" /* Decrement loop count */
  120. "     bnez   %1, 1b         n" /* loop test */
  121. "      addu   $1, $1, %0    n" /* Next address */
  122. ".set pop                   n"
  123. :
  124. : "r" (icache_line_size), "r" (icache_sets * icache_assoc),
  125.   "r" (KSEG0), "i" (Index_Invalidate_I));
  126. }
  128. #ifdef CONFIG_SMP
  129. extern void sb1___flush_cache_all_ipi(void *ignored);
  130. asm("sb1___flush_cache_all_ipi = local_sb1___flush_cache_all");
  132. static void sb1___flush_cache_all(void)
  133. {
  134. smp_call_function(sb1___flush_cache_all_ipi, 0, 1, 1);
  135. local_sb1___flush_cache_all();
  136. }
  137. #else
  138. extern void sb1___flush_cache_all(void);
  139. asm("sb1___flush_cache_all = local_sb1___flush_cache_all");
  140. #endif
  143. /*
  144.  * When flushing a range in the icache, we have to first writeback
  145.  * the dcache for the same range, so new ifetches will see any
  146.  * data that was dirty in the dcache.
  147.  *
  148.  * The start/end arguments are expected to be Kseg addresses.
  149.  */
  151. static void local_sb1_flush_icache_range(unsigned long start, unsigned long end)
  152. {
  153. #ifdef CONFIG_SB1_PASS_1_WORKAROUNDS
  154. unsigned long flags;
  155. local_irq_save(flags);
  156. #endif
  158. __asm__ __volatile__ (
  159. ".set push                  n"
  160. ".set noreorder             n"
  161. ".set noat                  n"
  162. ".set mips4                 n"
  163. "     move   $1, %0         n"
  164. "1:                         n"
  165. #ifdef CONFIG_SB1_PASS_1_WORKAROUNDS
  166. ".align 3                   n"
  167. "     lw     $0,   0($1)    n" /* Bug 1370, 1368            */
  168. "     sync                  n"
  169. #endif
  170. "     cache  %3, 0($1)      n" /* Hit-WB{,-inval} this address */
  171. "     bne    $1, %1, 1b     n" /* loop test */
  172. "      addu  $1, $1, %2     n" /* next line */
  173. ".set pop                   n"
  174. :
  175. : "r" (start  & ~(dcache_line_size - 1)),
  176.   "r" ((end - 1) & ~(dcache_line_size - 1)),
  177.   "r" (dcache_line_size),
  178. #ifdef CONFIG_SB1_PASS_1_WORKAROUNDS
  179.   "i" (Hit_Writeback_Inv_D)
  180. #else
  181.   "i" (Hit_Writeback_D)
  182. #endif
  183. );
  184. __asm__ __volatile__ (
  185. ".set push                  n"
  186. ".set noreorder             n"
  187. ".set mips2                 n"
  188. "sync                       n"
  189. #ifdef CONFIG_SB1_PASS_1_WORKAROUNDS /* Bug 1384 */
  190. "sync                       n"
  191. #endif
  192. ".set pop                   n");
  193. #ifdef CONFIG_SB1_PASS_1_WORKAROUNDS
  194. local_irq_restore(flags);
  195. #endif
  197. __asm__ __volatile__ (
  198. ".set push                  n"
  199. ".set noreorder             n"
  200. ".set noat                  n"
  201. ".set mips4                 n"
  202. "     move   $1, %0         n"
  203. ".align 3                   n"
  204. "1:   cache  %3, (0<<13)($1) n" /* Index-inval this address */
  205. "     cache  %3, (1<<13)($1) n" /* Index-inval this address */
  206. "     cache  %3, (2<<13)($1) n" /* Index-inval this address */
  207. "     cache  %3, (3<<13)($1) n" /* Index-inval this address */
  208. "     bne    $1, %1, 1b     n" /* loop test */
  209. "      addu  $1, $1, %2     n" /* next line */
  210. ".set pop                   n"
  211. :
  212. : "r" (start & ~(icache_line_size - 1)),
  213.   "r" ((end - 1) & ~(icache_line_size - 1)),
  214.   "r" (icache_line_size),
  215.   "i" (Index_Invalidate_I));
  216. }
  218. #ifdef CONFIG_SMP
  219. struct flush_icache_range_args {
  220. unsigned long start;
  221. unsigned long end;
  222. };
  224. static void sb1_flush_icache_range_ipi(void *info)
  225. {
  226. struct flush_icache_range_args *args = info;
  228. local_sb1_flush_icache_range(args->start, args->end);
  229. }
  231. void sb1_flush_icache_range(unsigned long start, unsigned long end)
  232. {
  233. struct flush_icache_range_args args;
  235. args.start = start;
  236. args.end = end;
  237. smp_call_function(sb1_flush_icache_range_ipi, &args, 1, 1);
  238. local_sb1_flush_icache_range(start, end);
  239. }
  240. #else
  241. void sb1_flush_icache_range(unsigned long start, unsigned long end);
  242. asm("sb1_flush_icache_range = local_sb1_flush_icache_range");
  243. #endif
  245. /*
  246.  * If there's no context yet, or the page isn't executable, no icache flush
  247.  * is needed
  248.  */
  249. static void sb1_flush_icache_page(struct vm_area_struct *vma,
  250. struct page *page)
  251. {
  252. if (!(vma->vm_flags & VM_EXEC))
  253. return;
  255. /*
  256.  * We're not sure of the virtual address(es) involved here, so
  257.  * conservatively flush the entire caches on all processors
  258.  * (ouch).
  259.  */
  260. sb1___flush_cache_all();
  261. }
  263. static inline void protected_flush_icache_line(unsigned long addr)
  264. {
  265. __asm__ __volatile__(
  266. "    .set push                n"
  267. "    .set noreorder           n"
  268. "    .set mips4               n"
  269. "1:  cache %1, (%0)           n"
  270. "2:  .set pop                 n"
  271. "    .section __ex_table,"a"n"
  272. "     .word  1b, 2b          n"
  273. "     .previous"
  274. :
  275. : "r" (addr),
  276.   "i" (Hit_Invalidate_I));
  277. }
  279. static inline void protected_writeback_dcache_line(unsigned long addr)
  280. {
  281. #ifdef CONFIG_SB1_PASS_1_WORKAROUNDS
  282. /* Have to be sure the TLB entry exists for the cache op,
  283.    so we have to be sure that nothing happens in between the
  284.    lw and the cache op
  285. */
  286. unsigned long flags;
  287. local_irq_save(flags);
  288. #endif
  289. __asm__ __volatile__(
  290. "    .set push                n"
  291. "    .set noreorder           n"
  292. "    .set mips4               n"
  293. "1:                           n"
  294. #ifdef CONFIG_SB1_PASS_1_WORKAROUNDS
  295. "     lw    $0,   (%0)        n"
  296. "     sync                  n"
  297. #endif
  298. "     cache  %1, 0(%0)    n" /* Hit-WB{-inval} this address */
  299. /* XXX: should be able to do this after both dcache cache
  300.    ops, but there's no guarantee that this will be inlined,
  301.    and the pass1 restriction checker can't detect syncs
  302.    following cache ops except in the following basic block.
  303. */
  304. "     sync                    n"
  305. #ifdef CONFIG_SB1_PASS_1_WORKAROUNDS /* Bug 1384 */
  306. "     sync                    n"
  307. #endif
  308. "2:  .set pop                 n"
  309. "    .section __ex_table,"a"n"
  310. "     .word  1b, 2b          n"
  311. "     .previous"
  312. :
  313. : "r" (addr),
  314. #ifdef CONFIG_SB1_PASS_1_WORKAROUNDS
  315.   "i" (Hit_Writeback_Inv_D)
  316. #else
  317.   "i" (Hit_Writeback_D)
  318. #endif
  319.   );
  320. #ifdef CONFIG_SB1_PASS_1_WORKAROUNDS
  321. local_irq_restore(flags);
  322. #endif
  323. }
  325. /*
  326.  * A signal trampoline must fit into a single cacheline.
  327.  */
  328. static void local_sb1_flush_cache_sigtramp(unsigned long addr)
  329. {
  330. unsigned long daddr, iaddr;
  332. daddr = addr & ~(dcache_line_size - 1);
  333. protected_writeback_dcache_line(daddr);
  334. iaddr = addr & ~(icache_line_size - 1);
  335. protected_flush_icache_line(iaddr);
  336. }
  338. #ifdef CONFIG_SMP
  340. static void sb1_flush_cache_sigtramp_ipi(void *info)
  341. {
  342. unsigned long iaddr = (unsigned long) info;
  344. iaddr = iaddr & ~(icache_line_size - 1);
  345. protected_flush_icache_line(iaddr);
  346. }
  348. static void sb1_flush_cache_sigtramp(unsigned long addr)
  349. {
  350. unsigned long tmp;
  352. /*
  353.  * Flush the local dcache, then load the instruction back into a
  354.  * register.  That will make sure that any remote CPU also has
  355.  * written back it's data cache to memory.
  356.  */
  357. local_sb1_flush_cache_sigtramp(addr);
  358. __get_user(tmp, (unsigned long *)addr);
  360. smp_call_function(sb1_flush_cache_sigtramp_ipi, (void *) addr, 1, 1);
  361. }
  363. #else
  364. void sb1_flush_cache_sigtramp(unsigned long addr);
  365. asm("sb1_flush_cache_sigtramp = local_sb1_flush_cache_sigtramp");
  366. #endif
  368. static void sb1_flush_icache_all(void)
  369. {
  370. /*
  371.  * Haven't worried too much about speed here; given that we're flushing
  372.  * the icache, the time to invalidate is dwarfed by the time it's going
  373.  * to take to refill it.  Register usage:
  374.  *
  375.  * $1 - moving cache index
  376.  * $2 - set count
  377.  */
  378. __asm__ __volatile__ (
  379. ".set push                  n"
  380. ".set noreorder             n"
  381. ".set noat                  n"
  382. ".set mips4                 n"
  383. "     move   $1, %2         n" /* Start at index 0 */
  384. "1:   cache  %3, 0($1)      n" /* Invalidate this index */
  385. "     addiu  %1, %1, -1     n" /* Decrement loop count */
  386. "     bnez   %1, 1b         n" /* loop test */
  387. "      addu   $1, $1, %0    n" /* Next address */
  388. ".set pop                   n"
  389. :
  390. : "r" (icache_line_size), "r" (icache_sets * icache_assoc),
  391.   "r" (KSEG0), "i" (Index_Invalidate_I));
  392. }
  394. /*
  395.  * Anything that just flushes dcache state can be ignored, as we're always
  396.  * coherent in dcache space.  This is just a dummy function that all the
  397.  * nop'ed routines point to
  398.  */
  400. static void sb1_nop(void)
  401. {
  402. }
  404. /*
  405.  * This only needs to make sure stores done up to this
  406.  * point are visible to other agents outside the CPU.  Given
  407.  * the coherent nature of the ZBbus, all that's required here is
  408.  * a sync to make sure the data gets out to the caches and is
  409.  * visible to an arbitrary A Phase from an external agent
  410.  *
  411.  * Actually, I'm not even sure that's necessary; the semantics
  412.  * of this function aren't clear.  If it's supposed to serve as
  413.  * a memory barrier, this is needed.  If it's only meant to
  414.  * prevent data from being invisible to non-cpu memory accessors
  415.  * for some indefinite period of time (e.g. in a non-coherent
  416.  * dcache) then this function would be a complete nop.
  417.  */
  418. static void sb1_flush_page_to_ram(struct page *page)
  419. {
  420. __asm__ __volatile__(
  421. "     sync  n"  /* Short pipe */
  422. :::"memory");
  423. }
  425. /*
  426.  *  Cache set values (from the mips64 spec)
  427.  * 0 - 64
  428.  * 1 - 128
  429.  * 2 - 256
  430.  * 3 - 512
  431.  * 4 - 1024
  432.  * 5 - 2048
  433.  * 6 - 4096
  434.  * 7 - Reserved
  435.  */
  437. static unsigned int decode_cache_sets(unsigned int config_field)
  438. {
  439. if (config_field == 7) {
  440. /* JDCXXX - Find a graceful way to abort. */
  441. return 0;
  442. }
  443. return (1<<(config_field + 6));
  444. }
  446. /*
  447.  *  Cache line size values (from the mips64 spec)
  448.  * 0 - No cache present.
  449.  * 1 - 4 bytes
  450.  * 2 - 8 bytes
  451.  * 3 - 16 bytes
  452.  * 4 - 32 bytes
  453.  * 5 - 64 bytes
  454.  * 6 - 128 bytes
  455.  * 7 - Reserved
  456.  */
  458. static unsigned int decode_cache_line_size(unsigned int config_field)
  459. {
  460. if (config_field == 0) {
  461. return 0;
  462. } else if (config_field == 7) {
  463. /* JDCXXX - Find a graceful way to abort. */
  464. return 0;
  465. }
  466. return (1<<(config_field + 1));
  467. }
  469. /*
  470.  * Relevant bits of the config1 register format (from the MIPS32/MIPS64 specs)
  471.  *
  472.  * 24:22 Icache sets per way
  473.  * 21:19 Icache line size
  474.  * 18:16 Icache Associativity
  475.  * 15:13 Dcache sets per way
  476.  * 12:10 Dcache line size
  477.  * 9:7   Dcache Associativity
  478.  */
  480. static __init void probe_cache_sizes(void)
  481. {
  482. u32 config1;
  484. config1 = read_mips32_cp0_config1();
  485. icache_line_size = decode_cache_line_size((config1 >> 19) & 0x7);
  486. dcache_line_size = decode_cache_line_size((config1 >> 10) & 0x7);
  487. icache_sets = decode_cache_sets((config1 >> 22) & 0x7);
  488. dcache_sets = decode_cache_sets((config1 >> 13) & 0x7);
  489. icache_assoc = ((config1 >> 16) & 0x7) + 1;
  490. dcache_assoc = ((config1 >> 7) & 0x7) + 1;
  491. icache_size = icache_line_size * icache_sets * icache_assoc;
  492. dcache_size = dcache_line_size * dcache_sets * dcache_assoc;
  493. icache_index_mask = (icache_sets - 1) * icache_line_size;
  494. }
  496. /*
  497.  * This is called from loadmmu.c.  We have to set up all the
  498.  * memory management function pointers, as well as initialize
  499.  * the caches and tlbs
  500.  */
  501. void ld_mmu_sb1(void)
  502. {
  503. probe_cache_sizes();
  505. _clear_page = sb1_clear_page;
  506. _copy_page = sb1_copy_page;
  508. _flush_cache_all = sb1_flush_cache_all;
  509. ___flush_cache_all = sb1___flush_cache_all;
  510. _flush_cache_mm = (void (*)(struct mm_struct *))sb1_nop;
  511. _flush_cache_range = (void *) sb1_nop;
  512. _flush_page_to_ram = sb1_flush_page_to_ram;
  513. _flush_icache_page = sb1_flush_icache_page;
  514. _flush_icache_range = sb1_flush_icache_range;
  516. /* None of these are needed for the sb1 */
  517. _flush_cache_page = (void *) sb1_nop;
  519. _flush_cache_sigtramp = sb1_flush_cache_sigtramp;
  520. _flush_icache_all = sb1_flush_icache_all;
  522. change_cp0_config(CONF_CM_CMASK, CONF_CM_DEFAULT);
  523. flush_cache_all();
  524. }