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

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

Linux/Unix编程

开发平台：

Unix_Linux

mtrr.c：源码内容
  1. /*  x86-64 MTRR (Memory Type Range Register) driver.
  2. Based largely upon arch/i386/kernel/mtrr.c
  4. Copyright (C) 1997-2000  Richard Gooch
  5. Copyright (C) 2002 Dave Jones.
  7. This library is free software; you can redistribute it and/or
  8. modify it under the terms of the GNU Library General Public
  9. License as published by the Free Software Foundation; either
  10. version 2 of the License, or (at your option) any later version.
  12. This library is distributed in the hope that it will be useful,
  13. but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15. Library General Public License for more details.
  17. You should have received a copy of the GNU Library General Public
  18. License along with this library; if not, write to the Free
  19. Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21. (For earlier history, see arch/i386/kernel/mtrr.c)
  22. v2.00 September 2001 Dave Jones <davej@suse.de>
  23.   Initial rewrite for x86-64.
  24.   Removal of non-Intel style MTRR code.
  25. v2.01  June 2002  Dave Jones <davej@suse.de>
  26.   Removal of redundant abstraction layer.
  27.   64-bit fixes.
  28. v2.02  July 2002  Dave Jones <davej@suse.de>
  29.   Fix gentry inconsistencies between kernel/userspace.
  30.   More casts to clean up warnings.
  31. */
  33. #include <linux/types.h>
  34. #include <linux/errno.h>
  35. #include <linux/sched.h>
  36. #include <linux/tty.h>
  37. #include <linux/timer.h>
  38. #include <linux/config.h>
  39. #include <linux/kernel.h>
  40. #include <linux/wait.h>
  41. #include <linux/string.h>
  42. #include <linux/slab.h>
  43. #include <linux/ioport.h>
  44. #include <linux/delay.h>
  45. #include <linux/fs.h>
  46. #include <linux/ctype.h>
  47. #include <linux/proc_fs.h>
  48. #include <linux/devfs_fs_kernel.h>
  49. #include <linux/mm.h>
  50. #include <linux/module.h>
  51. #define MTRR_NEED_STRINGS
  52. #include <asm/mtrr.h>
  53. #include <linux/init.h>
  54. #include <linux/smp.h>
  55. #include <linux/smp_lock.h>
  56. #include <linux/agp_backend.h>
  58. #include <asm/uaccess.h>
  59. #include <asm/io.h>
  60. #include <asm/processor.h>
  61. #include <asm/system.h>
  62. #include <asm/pgtable.h>
  63. #include <asm/segment.h>
  64. #include <asm/bitops.h>
  65. #include <asm/atomic.h>
  66. #include <asm/msr.h>
  68. #include <asm/hardirq.h>
  69. #include <linux/irq.h>
  71. #define MTRR_VERSION "2.02 (20020716)"
  73. #undef Dprintk
  75. #define Dprintk(...) 
  77. #define TRUE  1
  78. #define FALSE 0
  80. #define MSR_MTRRphysBase(reg) (0x200 + 2 * (reg))
  81. #define MSR_MTRRphysMask(reg) (0x200 + 2 * (reg) + 1)
  83. #define NUM_FIXED_RANGES 88
  85. #define MTRR_CHANGE_MASK_FIXED 0x01
  86. #define MTRR_CHANGE_MASK_VARIABLE 0x02
  87. #define MTRR_CHANGE_MASK_DEFTYPE 0x04
  89. typedef u8 mtrr_type;
  91. #define LINE_SIZE 80
  93. #ifdef CONFIG_SMP
  94. #define set_mtrr(reg,base,size,type) set_mtrr_smp (reg, base, size, type)
  95. #else
  96. #define set_mtrr(reg,base,size,type) set_mtrr_up (reg, base, size, type, TRUE)
  97. #endif
  99. #if defined(CONFIG_PROC_FS) || defined(CONFIG_DEVFS_FS)
  100. #define USERSPACE_INTERFACE
  101. #endif
  103. #ifdef USERSPACE_INTERFACE
  104. static char *ascii_buffer;
  105. static unsigned int ascii_buf_bytes;
  106. static void compute_ascii (void);
  107. #else
  108. #define compute_ascii() while (0)
  109. #endif
  111. static unsigned int *usage_table;
  112. static DECLARE_MUTEX (mtrr_lock);
  114. struct set_mtrr_context {
  115. u32 deftype_lo;
  116. u32 deftype_hi;
  117. unsigned long flags;
  118. u64 cr4val;
  119. };
  122. /*  Put the processor into a state where MTRRs can be safely set  */
  123. static void set_mtrr_prepare (struct set_mtrr_context *ctxt)
  124. {
  125. u64 cr0;
  127. /* Disable interrupts locally */
  128. __save_flags(ctxt->flags);
  129. __cli();
  131. /* Save value of CR4 and clear Page Global Enable (bit 7) */
  132. if (test_bit(X86_FEATURE_PGE, boot_cpu_data.x86_capability)) {
  133. ctxt->cr4val = read_cr4();
  134. write_cr4(ctxt->cr4val & ~(1UL << 7));
  135. }
  137. /* Disable and flush caches. Note that wbinvd flushes the TLBs as
  138.    a side-effect */
  139. cr0 = read_cr0() | 0x40000000;
  140. wbinvd();
  141. write_cr0(cr0);
  142. wbinvd();
  144. /* Disable MTRRs, and set the default type to uncached */
  145. rdmsr(MSR_MTRRdefType, ctxt->deftype_lo, ctxt->deftype_hi);
  146. wrmsr(MSR_MTRRdefType, ctxt->deftype_lo & 0xf300UL, ctxt->deftype_hi);
  147. }
  150. /* Restore the processor after a set_mtrr_prepare */
  151. static void set_mtrr_done (struct set_mtrr_context *ctxt)
  152. {
  153. /* Flush caches and TLBs */
  154. wbinvd();
  156. /* Restore MTRRdefType */
  157. wrmsr(MSR_MTRRdefType, ctxt->deftype_lo, ctxt->deftype_hi);
  159. /* Enable caches */
  160. write_cr0(read_cr0() & 0xbfffffff);
  162. /* Restore value of CR4 */
  163. if (test_bit(X86_FEATURE_PGE, boot_cpu_data.x86_capability))
  164. write_cr4 (ctxt->cr4val);
  166. /* Re-enable interrupts locally (if enabled previously) */
  167. __restore_flags(ctxt->flags);
  168. }
  171. /*  This function returns the number of variable MTRRs  */
  172. static unsigned int get_num_var_ranges (void)
  173. {
  174. u32 config, dummy;
  176. rdmsr (MSR_MTRRcap, config, dummy);
  177. return (config & 0xff);
  178. }
  181. /*  Returns non-zero if we have the write-combining memory type  */
  182. static int have_wrcomb (void)
  183. {
  184. u32 config, dummy;
  186. rdmsr (MSR_MTRRcap, config, dummy);
  187. return (config & (1 << 10));
  188. }
  191. static u64 size_or_mask, size_and_mask;
  193. static void get_mtrr (unsigned int reg, u64 *base, u32 *size, mtrr_type * type)
  194. {
  195. u32 mask_lo, mask_hi, base_lo, base_hi;
  196. u64 newsize;
  198. rdmsr (MSR_MTRRphysMask(reg), mask_lo, mask_hi);
  199. if ((mask_lo & 0x800) == 0) {
  200. /*  Invalid (i.e. free) range  */
  201. *base = 0;
  202. *size = 0;
  203. *type = 0;
  204. return;
  205. }
  207. rdmsr (MSR_MTRRphysBase(reg), base_lo, base_hi);
  209. /* Work out the shifted address mask. */
  210. newsize = (u64) mask_hi << 32 | (mask_lo & ~0x800);
  211. newsize = ~newsize+1;
  212. *size = (u32) newsize >> PAGE_SHIFT;
  213. *base = base_hi << (32 - PAGE_SHIFT) | base_lo >> PAGE_SHIFT;
  214. *type = base_lo & 0xff;
  215. }
  219. /*
  220.  * Set variable MTRR register on the local CPU.
  221.  *  <reg> The register to set.
  222.  *  <base> The base address of the region.
  223.  *  <size> The size of the region. If this is 0 the region is disabled.
  224.  *  <type> The type of the region.
  225.  *  <do_safe> If TRUE, do the change safely. If FALSE, safety measures should
  226.  *  be done externally.
  227.  */
  228. static void set_mtrr_up (unsigned int reg, u64 base,
  229.    u32 size, mtrr_type type, int do_safe)
  230. {
  231. struct set_mtrr_context ctxt;
  232. u64 base64;
  233. u64 size64;
  235. if (do_safe)
  236. set_mtrr_prepare (&ctxt);
  238. if (size == 0) {
  239. /* The invalid bit is kept in the mask, so we simply clear the
  240.    relevant mask register to disable a range. */
  241. wrmsr (MSR_MTRRphysMask(reg), 0, 0);
  242. } else {
  243. base64 = (base << PAGE_SHIFT) & size_and_mask;
  244. wrmsr (MSR_MTRRphysBase(reg), base64 | type, base64 >> 32);
  246. size64 = ~((size << PAGE_SHIFT) - 1);
  247. size64 = size64 & size_and_mask;
  248. wrmsr (MSR_MTRRphysMask(reg), (u32) (size64 | 0x800), (u32) (size64 >> 32));
  249. }
  250. if (do_safe)
  251. set_mtrr_done (&ctxt);
  252. }
  255. #ifdef CONFIG_SMP
  257. struct mtrr_var_range {
  258. u32 base_lo;
  259. u32 base_hi;
  260. u32 mask_lo;
  261. u32 mask_hi;
  262. };
  264. /*  Get the MSR pair relating to a var range  */
  265. static void __init get_mtrr_var_range (unsigned int index,
  266. struct mtrr_var_range *vr)
  267. {
  268. rdmsr (MSR_MTRRphysBase(index), vr->base_lo, vr->base_hi);
  269. rdmsr (MSR_MTRRphysMask(index), vr->mask_lo, vr->mask_hi);
  270. }
  273. /*  Set the MSR pair relating to a var range. Returns TRUE if
  274.     changes are made  */
  275. static int __init set_mtrr_var_range_testing (unsigned int index,
  276. struct mtrr_var_range *vr)
  277. {
  278. u32 lo, hi;
  279. int changed = FALSE;
  281. rdmsr (MSR_MTRRphysBase(index), lo, hi);
  282. if ((vr->base_lo & 0xfffff0ff) != (lo & 0xfffff0ff) ||
  283. (vr->base_hi & 0x000fffff) != (hi & 0x000fffff)) {
  284. wrmsr (MSR_MTRRphysBase(index), vr->base_lo, vr->base_hi);
  285. changed = TRUE;
  286. }
  288. rdmsr (MSR_MTRRphysMask(index), lo, hi);
  289. if ((vr->mask_lo & 0xfffff800) != (lo & 0xfffff800) ||
  290. (vr->mask_hi & 0x000fffff) != (hi & 0x000fffff)) {
  291. wrmsr (MSR_MTRRphysMask(index), vr->mask_lo, vr->mask_hi);
  292. changed = TRUE;
  293. }
  294. return changed;
  295. }
  298. static void __init get_fixed_ranges (mtrr_type * frs)
  299. {
  300. u32 *p = (u32 *) frs;
  301. int i;
  303. rdmsr (MSR_MTRRfix64K_00000, p[0], p[1]);
  305. for (i = 0; i < 2; i++)
  306. rdmsr (MSR_MTRRfix16K_80000 + i, p[2 + i * 2], p[3 + i * 2]);
  307. for (i = 0; i < 8; i++)
  308. rdmsr (MSR_MTRRfix4K_C0000 + i, p[6 + i * 2], p[7 + i * 2]);
  309. }
  312. static int __init set_fixed_ranges_testing (mtrr_type * frs)
  313. {
  314. u32 *p = (u32 *) frs;
  315. int changed = FALSE;
  316. int i;
  317. u32 lo, hi;
  319. Dprintk (KERN_INFO "mtrr: rdmsr 64K_00000n");
  320. rdmsr (MSR_MTRRfix64K_00000, lo, hi);
  321. if (p[0] != lo || p[1] != hi) {
  322. Dprintk (KERN_INFO "mtrr: Writing %x:%x to 64K MSR. lohi were %x:%xn", p[0], p[1], lo, hi);
  323. wrmsr (MSR_MTRRfix64K_00000, p[0], p[1]);
  324. changed = TRUE;
  325. }
  327. Dprintk (KERN_INFO "mtrr: rdmsr 16K_80000n");
  328. for (i = 0; i < 2; i++) {
  329. rdmsr (MSR_MTRRfix16K_80000 + i, lo, hi);
  330. if (p[2 + i * 2] != lo || p[3 + i * 2] != hi) {
  331. Dprintk (KERN_INFO "mtrr: Writing %x:%x to 16K MSR%d. lohi were %x:%xn", p[2 + i * 2], p[3 + i * 2], i, lo, hi );
  332. wrmsr (MSR_MTRRfix16K_80000 + i, p[2 + i * 2], p[3 + i * 2]);
  333. changed = TRUE;
  334. }
  335. }
  337. Dprintk (KERN_INFO "mtrr: rdmsr 4K_C0000n");
  338. for (i = 0; i < 8; i++) {
  339. rdmsr (MSR_MTRRfix4K_C0000 + i, lo, hi);
  340. Dprintk (KERN_INFO "mtrr: MTRRfix4K_C0000+%d = %x:%xn", i, lo, hi);
  341. if (p[6 + i * 2] != lo || p[7 + i * 2] != hi) {
  342. Dprintk (KERN_INFO "mtrr: Writing %x:%x to 4K MSR%d. lohi were %x:%xn", p[6 + i * 2], p[7 + i * 2], i, lo, hi);
  343. wrmsr (MSR_MTRRfix4K_C0000 + i, p[6 + i * 2], p[7 + i * 2]);
  344. changed = TRUE;
  345. }
  346. }
  347. return changed;
  348. }
  351. struct mtrr_state {
  352. unsigned int num_var_ranges;
  353. struct mtrr_var_range *var_ranges;
  354. mtrr_type fixed_ranges[NUM_FIXED_RANGES];
  355. mtrr_type def_type;
  356. unsigned char enabled;
  357. };
  360. /*  Grab all of the MTRR state for this CPU into *state  */
  361. static void __init get_mtrr_state (struct mtrr_state *state)
  362. {
  363. unsigned int nvrs, i;
  364. struct mtrr_var_range *vrs;
  365. u32 lo, dummy;
  367. nvrs = state->num_var_ranges = get_num_var_ranges();
  368. vrs = state->var_ranges
  369.     = kmalloc (nvrs * sizeof (struct mtrr_var_range), GFP_KERNEL);
  370. if (vrs == NULL)
  371. nvrs = state->num_var_ranges = 0;
  373. for (i = 0; i < nvrs; i++)
  374. get_mtrr_var_range (i, &vrs[i]);
  375. get_fixed_ranges (state->fixed_ranges);
  377. rdmsr (MSR_MTRRdefType, lo, dummy);
  378. state->def_type = (lo & 0xff);
  379. state->enabled = (lo & 0xc00) >> 10;
  380. }
  383. /*  Free resources associated with a struct mtrr_state  */
  384. static void __init finalize_mtrr_state (struct mtrr_state *state)
  385. {
  386. if (state->var_ranges)
  387. kfree (state->var_ranges);
  388. }
  391. /*
  392.  * Set the MTRR state for this CPU.
  393.  *  <state> The MTRR state information to read.
  394.  *  <ctxt> Some relevant CPU context.
  395.  *  [NOTE] The CPU must already be in a safe state for MTRR changes.
  396.  *  [RETURNS] 0 if no changes made, else a mask indication what was changed.
  397.  */
  398. static u64 __init set_mtrr_state (struct mtrr_state *state,
  399. struct set_mtrr_context *ctxt)
  400. {
  401. unsigned int i;
  402. u64 change_mask = 0;
  404. for (i = 0; i < state->num_var_ranges; i++)
  405. if (set_mtrr_var_range_testing (i, &state->var_ranges[i]))
  406. change_mask |= MTRR_CHANGE_MASK_VARIABLE;
  408. if (set_fixed_ranges_testing (state->fixed_ranges))
  409. change_mask |= MTRR_CHANGE_MASK_FIXED;
  410. /* Set_mtrr_restore restores the old value of MTRRdefType,
  411.    so to set it we fiddle with the saved value  */
  412. if ((ctxt->deftype_lo & 0xff) != state->def_type
  413.     || ((ctxt->deftype_lo & 0xc00) >> 10) != state->enabled) {
  414. ctxt->deftype_lo |= (state->def_type | state->enabled << 10);
  415. change_mask |= MTRR_CHANGE_MASK_DEFTYPE;
  416. }
  418. return change_mask;
  419. }
  422. static atomic_t undone_count;
  423. static volatile int wait_barrier_execute = FALSE;
  424. static volatile int wait_barrier_cache_enable = FALSE;
  426. struct set_mtrr_data {
  427. u64 smp_base;
  428. u32 smp_size;
  429. unsigned int smp_reg;
  430. mtrr_type smp_type;
  431. };
  433. /*
  434.  * Synchronisation handler. Executed by "other" CPUs.
  435.  */
  436. static void ipi_handler (void *info)
  437. {
  438. struct set_mtrr_data *data = info;
  439. struct set_mtrr_context ctxt;
  441. set_mtrr_prepare (&ctxt);
  442. /* Notify master that I've flushed and disabled my cache  */
  443. atomic_dec (&undone_count);
  444. while (wait_barrier_execute)
  445. barrier ();
  447. /* The master has cleared me to execute  */
  448. set_mtrr_up (data->smp_reg, data->smp_base, data->smp_size,
  449. data->smp_type, FALSE);
  451. /* Notify master CPU that I've executed the function  */
  452. atomic_dec (&undone_count);
  454. /* Wait for master to clear me to enable cache and return  */
  455. while (wait_barrier_cache_enable)
  456. barrier ();
  457. set_mtrr_done (&ctxt);
  458. }
  461. static void set_mtrr_smp (unsigned int reg, u64 base, u32 size, mtrr_type type)
  462. {
  463. struct set_mtrr_data data;
  464. struct set_mtrr_context ctxt;
  466. data.smp_reg = reg;
  467. data.smp_base = base;
  468. data.smp_size = size;
  469. data.smp_type = type;
  470. wait_barrier_execute = TRUE;
  471. wait_barrier_cache_enable = TRUE;
  472. atomic_set (&undone_count, smp_num_cpus - 1);
  474. /*  Start the ball rolling on other CPUs  */
  475. if (smp_call_function (ipi_handler, &data, 1, 0) != 0)
  476. panic ("mtrr: timed out waiting for other CPUsn");
  478. /* Flush and disable the local CPU's cache */
  479. set_mtrr_prepare (&ctxt);
  481. /*  Wait for all other CPUs to flush and disable their caches  */
  482. while (atomic_read (&undone_count) > 0)
  483. barrier ();
  485. /* Set up for completion wait and then release other CPUs to change MTRRs */
  486. atomic_set (&undone_count, smp_num_cpus - 1);
  487. wait_barrier_execute = FALSE;
  488. set_mtrr_up (reg, base, size, type, FALSE);
  490. /*  Now wait for other CPUs to complete the function  */
  491. while (atomic_read (&undone_count) > 0)
  492. barrier ();
  494. /*  Now all CPUs should have finished the function. Release the barrier to
  495.    allow them to re-enable their caches and return from their interrupt,
  496.    then enable the local cache and return  */
  497. wait_barrier_cache_enable = FALSE;
  498. set_mtrr_done (&ctxt);
  499. }
  502. /*  Some BIOS's are fucked and don't set all MTRRs the same!  */
  503. static void __init mtrr_state_warn (u32 mask)
  504. {
  505. if (!mask)
  506. return;
  507. if (mask & MTRR_CHANGE_MASK_FIXED)
  508. printk (KERN_INFO "mtrr: your CPUs had inconsistent fixed MTRR settingsn");
  509. if (mask & MTRR_CHANGE_MASK_VARIABLE)
  510. printk (KERN_INFO "mtrr: your CPUs had inconsistent variable MTRR settingsn");
  511. if (mask & MTRR_CHANGE_MASK_DEFTYPE)
  512. printk (KERN_INFO "mtrr: your CPUs had inconsistent MTRRdefType settingsn");
  513. printk (KERN_INFO "mtrr: probably your BIOS does not setup all CPUsn");
  514. }
  516. #endif /*  CONFIG_SMP  */
  519. static inline char * attrib_to_str (int x)
  520. {
  521. return (x <= 6) ? mtrr_strings[x] : "?";
  522. }
  525. static void __init init_table (void)
  526. {
  527. int i, max;
  529. max = get_num_var_ranges ();
  530. if ((usage_table = kmalloc (max * sizeof *usage_table, GFP_KERNEL))==NULL) {
  531. printk ("mtrr: could not allocaten");
  532. return;
  533. }
  535. for (i = 0; i < max; i++)
  536. usage_table[i] = 1;
  538. #ifdef USERSPACE_INTERFACE
  539. if ((ascii_buffer = kmalloc (max * LINE_SIZE, GFP_KERNEL)) == NULL) {
  540. printk ("mtrr: could not allocaten");
  541. return;
  542. }
  543. ascii_buf_bytes = 0;
  544. compute_ascii ();
  545. #endif
  546. }
  549. /*
  550.  * Get a free MTRR.
  551.  * returns the index of the region on success, else -1 on error.
  552. */
  553. static int get_free_region(void)
  554. {
  555. int i, max;
  556. mtrr_type ltype;
  557. u64 lbase;
  558. u32 lsize;
  560. max = get_num_var_ranges ();
  561. for (i = 0; i < max; ++i) {
  562. get_mtrr (i, &lbase, &lsize, &ltype);
  563. if (lsize == 0)
  564. return i;
  565. }
  566. return -ENOSPC;
  567. }
  570. /**
  571.  * mtrr_add_page - Add a memory type region
  572.  * @base: Physical base address of region in pages (4 KB)
  573.  * @size: Physical size of region in pages (4 KB)
  574.  * @type: Type of MTRR desired
  575.  * @increment: If this is true do usage counting on the region
  576.  * Returns The MTRR register on success, else a negative number
  577.  * indicating the error code.
  578.  *
  579.  * Memory type region registers control the caching on newer
  580.  * processors. This function allows drivers to request an MTRR is added.
  581.  * The caller should expect to need to provide a power of two size on
  582.  * an equivalent power of two boundary.
  583.  *
  584.  * If the region cannot be added either because all regions are in use
  585.  * or the CPU cannot support it a negative value is returned. On success
  586.  * the register number for this entry is returned, but should be treated
  587.  * as a cookie only.
  588.  *
  589.  * On a multiprocessor machine the changes are made to all processors.
  590.  *
  591.  * The available types are
  592.  *
  593.  * %MTRR_TYPE_UNCACHABLE - No caching
  594.  * %MTRR_TYPE_WRBACK - Write data back in bursts whenever
  595.  * %MTRR_TYPE_WRCOMB - Write data back soon but allow bursts
  596.  * %MTRR_TYPE_WRTHROUGH - Cache reads but not writes
  597.  *
  598.  * BUGS: Needs a quiet flag for the cases where drivers do not mind
  599.  * failures and do not wish system log messages to be sent.
  600.  */
  602. int mtrr_add_page (u64 base, u32 size, unsigned int type, char increment)
  603. {
  604. int i, max;
  605. mtrr_type ltype;
  606. u64 lbase, last;
  607. u32 lsize;
  609. if (base + size < 0x100) {
  610. printk (KERN_WARNING
  611. "mtrr: cannot set region below 1 MiB (0x%Lx000,0x%x000)n",
  612. base, size);
  613. return -EINVAL;
  614. }
  616. #if 0 && defined(__x86_64__) && defined(CONFIG_AGP) 
  617. {
  618. agp_kern_info info; 
  619. if (type != MTRR_TYPE_UNCACHABLE && agp_copy_info(&info) >= 0 && 
  620.     base<<PAGE_SHIFT >= info.aper_base && 
  621.             (base<<PAGE_SHIFT)+(size<<PAGE_SHIFT) >= 
  622. info.aper_base+info.aper_size*1024*1024)
  623. printk(KERN_INFO "%s[%d] setting conflicting mtrr into agp aperturen",current->comm,current->pid); 
  624. }
  625. #endif
  627. /*  Check upper bits of base and last are equal and lower bits are 0
  628.    for base and 1 for last  */
  629. last = base + size - 1;
  630. for (lbase = base; !(lbase & 1) && (last & 1);
  631.      lbase = lbase >> 1, last = last >> 1) ;
  633. if (lbase != last) {
  634. printk (KERN_WARNING
  635. "mtrr: base(0x%Lx000) is not aligned on a size(0x%x000) boundaryn",
  636. base, size);
  637. return -EINVAL;
  638. }
  640. if (type >= MTRR_NUM_TYPES) {
  641. printk ("mtrr: type: %u illegaln", type);
  642. return -EINVAL;
  643. }
  645. /*  If the type is WC, check that this processor supports it  */
  646. if ((type == MTRR_TYPE_WRCOMB) && !have_wrcomb()) {
  647. printk (KERN_WARNING
  648. "mtrr: your processor doesn't support write-combiningn");
  649. return -ENOSYS;
  650. }
  652. if (base & (size_or_mask>>PAGE_SHIFT)) {
  653. printk (KERN_WARNING "mtrr: base(%Lx) exceeds the MTRR width(%Lx)n",
  654. base, (size_or_mask>>PAGE_SHIFT));
  655. return -EINVAL;
  656. }
  658. if (size & (size_or_mask>>PAGE_SHIFT)) {
  659. printk (KERN_WARNING "mtrr: size exceeds the MTRR widthn");
  660. return -EINVAL;
  661. }
  663. increment = increment ? 1 : 0;
  664. max = get_num_var_ranges ();
  665. /*  Search for existing MTRR  */
  666. down (&mtrr_lock);
  667. for (i = 0; i < max; ++i) {
  668. get_mtrr (i, &lbase, &lsize, &ltype);
  669. if (base >= lbase + lsize)
  670. continue;
  671. if ((base < lbase) && (base + size <= lbase))
  672. continue;
  674. /*  At this point we know there is some kind of overlap/enclosure  */
  675. if ((base < lbase) || (base + size > lbase + lsize)) {
  676. up (&mtrr_lock);
  677. printk (KERN_WARNING
  678. "mtrr: 0x%Lx000,0x%x000 overlaps existing"
  679. " 0x%Lx000,0x%x000n", base, size, lbase, lsize);
  680. return -EINVAL;
  681. }
  682. /*  New region is enclosed by an existing region  */
  683. if (ltype != type) {
  684. if (type == MTRR_TYPE_UNCACHABLE)
  685. continue;
  686. up (&mtrr_lock);
  687. printk
  688.     ("mtrr: type mismatch for %Lx000,%x000 old: %s new: %sn",
  689.      base, size,
  690.  attrib_to_str (ltype),
  691.      attrib_to_str (type));
  692. return -EINVAL;
  693. }
  694. if (increment)
  695. ++usage_table[i];
  696. compute_ascii ();
  697. up (&mtrr_lock);
  698. return i;
  699. }
  700. /*  Search for an empty MTRR  */
  701. i = get_free_region();
  702. if (i < 0) {
  703. up (&mtrr_lock);
  704. printk ("mtrr: no more MTRRs availablen");
  705. return i;
  706. }
  707. set_mtrr (i, base, size, type);
  708. usage_table[i] = 1;
  709. compute_ascii ();
  710. up (&mtrr_lock);
  711. return i;
  712. }
  715. /**
  716.  * mtrr_add - Add a memory type region
  717.  * @base: Physical base address of region
  718.  * @size: Physical size of region
  719.  * @type: Type of MTRR desired
  720.  * @increment: If this is true do usage counting on the region
  721.  * Return the MTRR register on success, else a negative numbe
  722.  * indicating the error code.
  723.  *
  724.  * Memory type region registers control the caching on newer processors.
  725.  * This function allows drivers to request an MTRR is added.
  726.  * The caller should expect to need to provide a power of two size on
  727.  * an equivalent power of two boundary.
  728.  *
  729.  * If the region cannot be added either because all regions are in use
  730.  * or the CPU cannot support it a negative value is returned. On success
  731.  * the register number for this entry is returned, but should be treated
  732.  * as a cookie only.
  733.  *
  734.  * On a multiprocessor machine the changes are made to all processors.
  735.  * This is required on x86 by the Intel processors.
  736.  *
  737.  * The available types are
  738.  *
  739.  * %MTRR_TYPE_UNCACHABLE - No caching
  740.  * %MTRR_TYPE_WRBACK - Write data back in bursts whenever
  741.  * %MTRR_TYPE_WRCOMB - Write data back soon but allow bursts
  742.  * %MTRR_TYPE_WRTHROUGH - Cache reads but not writes
  743.  *
  744.  * BUGS: Needs a quiet flag for the cases where drivers do not mind
  745.  * failures and do not wish system log messages to be sent.
  746.  */
  748. int mtrr_add (u64 base, u32 size, unsigned int type, char increment)
  749. {
  750. if ((base & (PAGE_SIZE - 1)) || (size & (PAGE_SIZE - 1))) {
  751. printk ("mtrr: size and base must be multiples of 4 kiBn");
  752. printk ("mtrr: size: 0x%x  base: 0x%Lxn", size, base);
  753. return -EINVAL;
  754. }
  755. return mtrr_add_page (base >> PAGE_SHIFT, size >> PAGE_SHIFT, type,
  756.       increment);
  757. }
  760. /**
  761.  * mtrr_del_page - delete a memory type region
  762.  * @reg: Register returned by mtrr_add
  763.  * @base: Physical base address
  764.  * @size: Size of region
  765.  *
  766.  * If register is supplied then base and size are ignored. This is
  767.  * how drivers should call it.
  768.  *
  769.  * Releases an MTRR region. If the usage count drops to zero the 
  770.  * register is freed and the region returns to default state.
  771.  * On success the register is returned, on failure a negative error
  772.  * code.
  773.  */
  775. int mtrr_del_page (int reg, u64 base, u32 size)
  776. {
  777. int i, max;
  778. mtrr_type ltype;
  779. u64 lbase;
  780. u32 lsize;
  782. max = get_num_var_ranges ();
  783. down (&mtrr_lock);
  784. if (reg < 0) {
  785. /*  Search for existing MTRR  */
  786. for (i = 0; i < max; ++i) {
  787. get_mtrr (i, &lbase, &lsize, &ltype);
  788. if (lbase == base && lsize == size) {
  789. reg = i;
  790. break;
  791. }
  792. }
  793. if (reg < 0) {
  794. up (&mtrr_lock);
  795. printk ("mtrr: no MTRR for %Lx000,%x000 foundn", base, size);
  796. return -EINVAL;
  797. }
  798. }
  800. if (reg >= max) {
  801. up (&mtrr_lock);
  802. printk ("mtrr: register: %d too bign", reg);
  803. return -EINVAL;
  804. }
  805. get_mtrr (reg, &lbase, &lsize, &ltype);
  807. if (lsize < 1) {
  808. up (&mtrr_lock);
  809. printk ("mtrr: MTRR %d not usedn", reg);
  810. return -EINVAL;
  811. }
  813. if (usage_table[reg] < 1) {
  814. up (&mtrr_lock);
  815. printk ("mtrr: reg: %d has count=0n", reg);
  816. return -EINVAL;
  817. }
  819. if (--usage_table[reg] < 1)
  820. set_mtrr (reg, 0, 0, 0);
  821. compute_ascii ();
  822. up (&mtrr_lock);
  823. return reg;
  824. }
  827. /**
  828.  * mtrr_del - delete a memory type region
  829.  * @reg: Register returned by mtrr_add
  830.  * @base: Physical base address
  831.  * @size: Size of region
  832.  *
  833.  * If register is supplied then base and size are ignored. This is
  834.  * how drivers should call it.
  835.  *
  836.  * Releases an MTRR region. If the usage count drops to zero the 
  837.  * register is freed and the region returns to default state.
  838.  * On success the register is returned, on failure a negative error
  839.  * code.
  840.  */
  842. int mtrr_del (int reg, u64 base, u32 size)
  843. {
  844. if ((base & (PAGE_SIZE - 1)) || (size & (PAGE_SIZE - 1))) {
  845. printk ("mtrr: size and base must be multiples of 4 kiBn");
  846. printk ("mtrr: size: 0x%x  base: 0x%Lxn", size, base);
  847. return -EINVAL;
  848. }
  849. return mtrr_del_page (reg, base >> PAGE_SHIFT, size >> PAGE_SHIFT);
  850. }
  853. #ifdef USERSPACE_INTERFACE
  855. static int mtrr_file_add (u64 base, u32 size, unsigned int type,
  856. struct file *file, int page)
  857. {
  858. int reg, max;
  859. unsigned int *fcount = file->private_data;
  861. max = get_num_var_ranges ();
  862. if (fcount == NULL) {
  863. if ((fcount =
  864.      kmalloc (max * sizeof *fcount, GFP_KERNEL)) == NULL) {
  865. printk ("mtrr: could not allocaten");
  866. return -ENOMEM;
  867. }
  868. memset (fcount, 0, max * sizeof *fcount);
  869. file->private_data = fcount;
  870. }
  872. if (!page) {
  873. if ((base & (PAGE_SIZE - 1)) || (size & (PAGE_SIZE - 1))) {
  874. printk
  875.     (KERN_INFO "mtrr: size and base must be multiples of 4 kiBn");
  876. printk (KERN_INFO "mtrr: size: 0x%x  base: 0x%Lxn", size, base);
  877. return -EINVAL;
  878. }
  879. base >>= PAGE_SHIFT;
  880. size >>= PAGE_SHIFT;
  881. }
  883. reg = mtrr_add_page (base, size, type, 1);
  885. if (reg >= 0)
  886. ++fcount[reg];
  887. return reg;
  888. }
  891. static int mtrr_file_del (u64 base, u32 size,
  892. struct file *file, int page)
  893. {
  894. int reg;
  895. unsigned int *fcount = file->private_data;
  897. if (!page) {
  898. if ((base & (PAGE_SIZE - 1)) || (size & (PAGE_SIZE - 1))) {
  899. printk
  900.     (KERN_INFO "mtrr: size and base must be multiples of 4 kiBn");
  901. printk (KERN_INFO "mtrr: size: 0x%x  base: 0x%Lxn", size, base);
  902. return -EINVAL;
  903. }
  904. base >>= PAGE_SHIFT;
  905. size >>= PAGE_SHIFT;
  906. }
  907. reg = mtrr_del_page (-1, base, size);
  908. if (reg < 0)
  909. return reg;
  910. if (fcount == NULL)
  911. return reg;
  912. if (fcount[reg] < 1)
  913. return -EINVAL;
  914. --fcount[reg];
  915. return reg;
  916. }
  919. static ssize_t mtrr_read (struct file *file, char *buf, size_t len,
  920. loff_t * ppos)
  921. {
  922. if (*ppos >= ascii_buf_bytes)
  923. return 0;
  925. if (*ppos + len > ascii_buf_bytes)
  926. len = ascii_buf_bytes - *ppos;
  928. if (copy_to_user (buf, ascii_buffer + *ppos, len))
  929. return -EFAULT;
  931. *ppos += len;
  932. return len;
  933. }
  936. static ssize_t mtrr_write (struct file *file, const char *buf,
  937. size_t len, loff_t * ppos)
  938. /*  Format of control line:
  939.     "base=%Lx size=%Lx type=%s"     OR:
  940.     "disable=%d"
  941. */
  942. {
  943. int i, err, reg;
  944. u64 base;
  945. u32 size;
  946. char *ptr;
  947. char line[LINE_SIZE];
  949. if (!capable(CAP_SYS_ADMIN))
  950. return -EPERM;
  952. /*  Can't seek (pwrite) on this device  */
  953. if (ppos != &file->f_pos)
  954. return -ESPIPE;
  955. memset (line, 0, LINE_SIZE);
  957. if (len > LINE_SIZE)
  958. len = LINE_SIZE;
  960. if (copy_from_user (line, buf, len - 1))
  961. return -EFAULT;
  962. ptr = line + strlen (line) - 1;
  964. if (*ptr == 'n')
  965. *ptr = '';
  967. if (!strncmp (line, "disable=", 8)) {
  968. reg = simple_strtoul (line + 8, &ptr, 0);
  969. err = mtrr_del_page (reg, 0, 0);
  970. if (err < 0)
  971. return err;
  972. return len;
  973. }
  975. if (strncmp (line, "base=", 5)) {
  976. printk (KERN_INFO "mtrr: no "base=" in line: "%s"n", line);
  977. return -EINVAL;
  978. }
  980. base = simple_strtoull (line + 5, &ptr, 0);
  982. for (; isspace (*ptr); ++ptr) ;
  984. if (strncmp (ptr, "size=", 5)) {
  985. printk (KERN_INFO "mtrr: no "size=" in line: "%s"n", line);
  986. return -EINVAL;
  987. }
  989. size = simple_strtoull (ptr + 5, &ptr, 0);
  991. if ((base & 0xfff) || (size & 0xfff)) {
  992. printk (KERN_INFO "mtrr: size and base must be multiples of 4 kiBn");
  993. printk (KERN_INFO "mtrr: size: 0x%x  base: 0x%Lxn", size, base);
  994. return -EINVAL;
  995. }
  997. for (; isspace (*ptr); ++ptr) ;
  999. if (strncmp (ptr, "type=", 5)) {
  1000. printk (KERN_INFO "mtrr: no "type=" in line: "%s"n", line);
  1001. return -EINVAL;
  1002. }
  1003. ptr += 5;
  1005. for (; isspace (*ptr); ++ptr) ;
  1007. for (i = 0; i < MTRR_NUM_TYPES; ++i) {
  1008. if (strcmp (ptr, mtrr_strings[i]))
  1009. continue;
  1010. base >>= PAGE_SHIFT;
  1011. size >>= PAGE_SHIFT;
  1012. err = mtrr_add_page ((u64) base, size, i, 1);
  1013. if (err < 0)
  1014. return err;
  1015. return len;
  1016. }
  1017. printk (KERN_INFO "mtrr: illegal type: "%s"n", ptr);
  1018. return -EINVAL;
  1019. }
  1022. static int mtrr_ioctl (struct inode *inode, struct file *file,
  1023. unsigned int cmd, unsigned long arg)
  1024. {
  1025. int err;
  1026. mtrr_type type;
  1027. struct mtrr_sentry sentry;
  1028. struct mtrr_gentry gentry;
  1030. switch (cmd) {
  1031. default:
  1032. return -ENOIOCTLCMD;
  1034. case MTRRIOC_ADD_ENTRY:
  1035. if (!capable(CAP_SYS_ADMIN))
  1036. return -EPERM;
  1037. if (copy_from_user (&sentry, (void *) arg, sizeof sentry))
  1038. return -EFAULT;
  1039. err = mtrr_file_add (sentry.base, sentry.size, sentry.type,
  1040.    file, 0);
  1041. if (err < 0)
  1042. return err;
  1043. break;
  1045. case MTRRIOC_SET_ENTRY:
  1046. if (!capable(CAP_SYS_ADMIN))
  1047. return -EPERM;
  1048. if (copy_from_user (&sentry, (void *) arg, sizeof sentry))
  1049. return -EFAULT;
  1050. err = mtrr_add (sentry.base, sentry.size, sentry.type, 0);
  1051. if (err < 0)
  1052. return err;
  1053. break;
  1055. case MTRRIOC_DEL_ENTRY:
  1056. if (!capable(CAP_SYS_ADMIN))
  1057. return -EPERM;
  1058. if (copy_from_user (&sentry, (void *) arg, sizeof sentry))
  1059. return -EFAULT;
  1060. err = mtrr_file_del (sentry.base, sentry.size, file, 0);
  1061. if (err < 0)
  1062. return err;
  1063. break;
  1065. case MTRRIOC_KILL_ENTRY:
  1066. if (!capable(CAP_SYS_ADMIN))
  1067. return -EPERM;
  1068. if (copy_from_user (&sentry, (void *) arg, sizeof sentry))
  1069. return -EFAULT;
  1070. err = mtrr_del (-1, sentry.base, sentry.size);
  1071. if (err < 0)
  1072. return err;
  1073. break;
  1075. case MTRRIOC_GET_ENTRY:
  1076. if (copy_from_user (&gentry, (void *) arg, sizeof gentry))
  1077. return -EFAULT;
  1078. if (gentry.regnum >= get_num_var_ranges ())
  1079. return -EINVAL;
  1080. get_mtrr (gentry.regnum, (u64*) &gentry.base, &gentry.size, &type);
  1082. /* Hide entries that go above 4GB */
  1083. if (gentry.base + gentry.size > 0x100000
  1084.     || gentry.size == 0x100000)
  1085. gentry.base = gentry.size = gentry.type = 0;
  1086. else {
  1087. gentry.base <<= PAGE_SHIFT;
  1088. gentry.size <<= PAGE_SHIFT;
  1089. gentry.type = type;
  1090. }
  1092. if (copy_to_user ((void *) arg, &gentry, sizeof gentry))
  1093. return -EFAULT;
  1094. break;
  1096. case MTRRIOC_ADD_PAGE_ENTRY:
  1097. if (!capable(CAP_SYS_ADMIN))
  1098. return -EPERM;
  1099. if (copy_from_user (&sentry, (void *) arg, sizeof sentry))
  1100. return -EFAULT;
  1101. err = mtrr_file_add (sentry.base, sentry.size, sentry.type, file, 1);
  1102. if (err < 0)
  1103. return err;
  1104. break;
  1106. case MTRRIOC_SET_PAGE_ENTRY:
  1107. if (!capable(CAP_SYS_ADMIN))
  1108. return -EPERM;
  1109. if (copy_from_user (&sentry, (void *) arg, sizeof sentry))
  1110. return -EFAULT;
  1111. err = mtrr_add_page (sentry.base, sentry.size, sentry.type, 0);
  1112. if (err < 0)
  1113. return err;
  1114. break;
  1116. case MTRRIOC_DEL_PAGE_ENTRY:
  1117. if (!capable(CAP_SYS_ADMIN))
  1118. return -EPERM;
  1119. if (copy_from_user (&sentry, (void *) arg, sizeof sentry))
  1120. return -EFAULT;
  1121. err = mtrr_file_del (sentry.base, sentry.size, file, 1);
  1122. if (err < 0)
  1123. return err;
  1124. break;
  1126. case MTRRIOC_KILL_PAGE_ENTRY:
  1127. if (!capable(CAP_SYS_ADMIN))
  1128. return -EPERM;
  1129. if (copy_from_user (&sentry, (void *) arg, sizeof sentry))
  1130. return -EFAULT;
  1131. err = mtrr_del_page (-1, sentry.base, sentry.size);
  1132. if (err < 0)
  1133. return err;
  1134. break;
  1136. case MTRRIOC_GET_PAGE_ENTRY:
  1137. if (copy_from_user (&gentry, (void *) arg, sizeof gentry))
  1138. return -EFAULT;
  1139. if (gentry.regnum >= get_num_var_ranges ())
  1140. return -EINVAL;
  1141. get_mtrr (gentry.regnum, (u64*) &gentry.base, &gentry.size, &type);
  1142. gentry.type = type;
  1144. if (copy_to_user ((void *) arg, &gentry, sizeof gentry))
  1145. return -EFAULT;
  1146. break;
  1147. }
  1148. return 0;
  1149. }
  1152. static int mtrr_close (struct inode *ino, struct file *file)
  1153. {
  1154. int i, max;
  1155. unsigned int *fcount = file->private_data;
  1157. if (fcount == NULL)
  1158. return 0;
  1160. lock_kernel ();
  1161. max = get_num_var_ranges ();
  1162. for (i = 0; i < max; ++i) {
  1163. while (fcount[i] > 0) {
  1164. if (mtrr_del (i, 0, 0) < 0)
  1165. printk ("mtrr: reg %d not usedn", i);
  1166. --fcount[i];
  1167. }
  1168. }
  1169. unlock_kernel ();
  1170. kfree (fcount);
  1171. file->private_data = NULL;
  1172. return 0;
  1173. }
  1176. static struct file_operations mtrr_fops = {
  1177. owner: THIS_MODULE,
  1178. read: mtrr_read,
  1179. write: mtrr_write,
  1180. ioctl: mtrr_ioctl,
  1181. release:mtrr_close,
  1182. };
  1184. #ifdef CONFIG_PROC_FS
  1185. static struct proc_dir_entry *proc_root_mtrr;
  1186. #endif
  1188. static devfs_handle_t devfs_handle;
  1190. static void compute_ascii (void)
  1191. {
  1192. char factor;
  1193. int i, max;
  1194. mtrr_type type;
  1195. u64 base;
  1196. u32 size;
  1198. ascii_buf_bytes = 0;
  1199. max = get_num_var_ranges ();
  1200. for (i = 0; i < max; i++) {
  1201. get_mtrr (i, &base, &size, &type);
  1202. if (size == 0)
  1203. usage_table[i] = 0;
  1204. else {
  1205. if (size < (0x100000 >> PAGE_SHIFT)) {
  1206. /* less than 1MB */
  1207. factor = 'K';
  1208. size <<= PAGE_SHIFT - 10;
  1209. } else {
  1210. factor = 'M';
  1211. size >>= 20 - PAGE_SHIFT;
  1212. }
  1213. sprintf (ascii_buffer + ascii_buf_bytes,
  1214. "reg%02i: base=0x%05Lx000 (%4iMB), size=%4i%cB: %s, count=%dn",
  1215. i, base, (u32) base >> (20 - PAGE_SHIFT), size, factor,
  1216. attrib_to_str (type), usage_table[i]);
  1217. ascii_buf_bytes += strlen (ascii_buffer + ascii_buf_bytes);
  1218. }
  1219. }
  1220. devfs_set_file_size (devfs_handle, ascii_buf_bytes);
  1221. #ifdef CONFIG_PROC_FS
  1222. if (proc_root_mtrr)
  1223. proc_root_mtrr->size = ascii_buf_bytes;
  1224. #endif
  1225. }
  1227. #endif /*  USERSPACE_INTERFACE  */
  1229. EXPORT_SYMBOL (mtrr_add);
  1230. EXPORT_SYMBOL (mtrr_del);
  1233. static void __init mtrr_setup (void)
  1234. {
  1235. printk ("mtrr: v%s)n", MTRR_VERSION);
  1237. if (test_bit (X86_FEATURE_MTRR, boot_cpu_data.x86_capability)) {
  1238. /* Query the width (in bits) of the physical
  1239.    addressable memory on the Hammer family. */
  1240. if ((cpuid_eax (0x80000000) >= 0x80000008)) {
  1241. u32 phys_addr;
  1242. phys_addr = cpuid_eax (0x80000008) & 0xff;
  1243. size_or_mask = ~((1L << phys_addr) - 1);
  1244. /*
  1245.  * top bits MBZ as its beyond the addressable range.
  1246.  * bottom bits MBZ as we don't care about lower 12 bits of addr.
  1247.  */
  1248. size_and_mask = (~size_or_mask) & 0x000ffffffffff000L;
  1249. }
  1250. }
  1251. }
  1253. #ifdef CONFIG_SMP
  1255. static volatile u32 smp_changes_mask __initdata = 0;
  1256. static struct mtrr_state smp_mtrr_state __initdata = { 0, 0 };
  1258. void __init mtrr_init_boot_cpu (void)
  1259. {
  1260. mtrr_setup();
  1261. get_mtrr_state (&smp_mtrr_state);
  1262. }
  1265. void __init mtrr_init_secondary_cpu (void)
  1266. {
  1267. u64 mask;
  1268. int count;
  1269. struct set_mtrr_context ctxt;
  1271. /* Note that this is not ideal, since the cache is only flushed/disabled
  1272.    for this CPU while the MTRRs are changed, but changing this requires
  1273.    more invasive changes to the way the kernel boots  */
  1274. set_mtrr_prepare (&ctxt);
  1275. mask = set_mtrr_state (&smp_mtrr_state, &ctxt);
  1276. set_mtrr_done (&ctxt);
  1278. /*  Use the atomic bitops to update the global mask  */
  1279. for (count = 0; count < sizeof mask * 8; ++count) {
  1280. if (mask & 0x01)
  1281. set_bit (count, &smp_changes_mask);
  1282. mask >>= 1;
  1283. }
  1284. }
  1286. #endif /*  CONFIG_SMP  */
  1289. int __init mtrr_init (void)
  1290. {
  1291. #ifdef CONFIG_SMP
  1292. /* mtrr_setup() should already have been called from mtrr_init_boot_cpu() */
  1294. finalize_mtrr_state (&smp_mtrr_state);
  1295. mtrr_state_warn (smp_changes_mask);
  1296. #else
  1297. mtrr_setup();
  1298. #endif
  1300. #ifdef CONFIG_PROC_FS
  1301. proc_root_mtrr = create_proc_entry ("mtrr", S_IWUSR | S_IRUGO, &proc_root);
  1302. if (proc_root_mtrr) {
  1303. proc_root_mtrr->owner = THIS_MODULE;
  1304. proc_root_mtrr->proc_fops = &mtrr_fops;
  1305. }
  1306. #endif
  1307. #ifdef CONFIG_DEVFS_FS
  1308. devfs_handle = devfs_register (NULL, "cpu/mtrr", DEVFS_FL_DEFAULT, 0, 0,
  1309. S_IFREG | S_IRUGO | S_IWUSR,
  1310. &mtrr_fops, NULL);
  1311. #endif
  1312. init_table ();
  1313. return 0;
  1314. }