arch/x86_64/kernel/msr.c

   1 /* ----------------------------------------------------------------------- *
   2  *
   3  *   Copyright 2000 H. Peter Anvin - All Rights Reserved
   4  *
   5  *   This program is free software; you can redistribute it and/or modify
   6  *   it under the terms of the GNU General Public License as published by
   7  *   the Free Software Foundation, Inc., 675 Mass Ave, Cambridge MA 02139,
   8  *   USA; either version 2 of the License, or (at your option) any later
   9  *   version; incorporated herein by reference.
  10  *
  11  * ----------------------------------------------------------------------- */
  12
  13 /*
  14  * msr.c
  15  *
  16  * x86 MSR access device
  17  *
  18  * This device is accessed by lseek() to the appropriate register number
  19  * and then read/write in chunks of 8 bytes.  A larger size means multiple
  20  * reads or writes of the same register.
  21  *
  22  * This driver uses /dev/cpu/%d/msr where %d is the minor number, and on
  23  * an SMP box will direct the access to CPU %d.
  24  */
  25
  26 #include <linux/module.h>
  27 #include <linux/config.h>
  28
  29 #include <linux/types.h>
  30 #include <linux/errno.h>
  31 #include <linux/fcntl.h>
  32 #include <linux/init.h>
  33 #include <linux/poll.h>
  34 #include <linux/smp.h>
  35 #include <linux/smp_lock.h>
  36 #include <linux/major.h>
  37 #include <linux/fs.h>
  38
  39 #include <asm/processor.h>
  40 #include <asm/msr.h>
  41 #include <asm/uaccess.h>
  42 #include <asm/system.h>
  43
  44 /* Note: "err" is handled in a funny way below.  Otherwise one version
  45    of gcc or another breaks. */
  46
  47 static inline int wrmsr_eio(u32 reg, u32 eax, u32 edx)
  48 {
  49   int err;
  50
  51   asm volatile(
  52                "1:      wrmsr\n"
  53                "2:\n"
  54                ".section .fixup,\"ax\"\n"
  55                "3:      movl %4,%0\n"
  56                "        jmp 2b\n"
  57                ".previous\n"
  58                ".section __ex_table,\"a\"\n"
  59                "        .align 8\n"
  60                "        .quad 1b,3b\n"
  61                ".previous"
  62                : "=&bDS" (err)
  63                : "a" (eax), "d" (edx), "c" (reg), "i" (-EIO), "0" (0));
  64
  65   return err;
  66 }
  67
  68 static inline int rdmsr_eio(u32 reg, u32 *eax, u32 *edx)
  69 {
  70   int err;
  71
  72   asm volatile(
  73                "1:      rdmsr\n"
  74                "2:\n"
  75                ".section .fixup,\"ax\"\n"
  76                "3:      movl %4,%0\n"
  77                "        jmp 2b\n"
  78                ".previous\n"
  79                ".section __ex_table,\"a\"\n"
  80                "        .align 8\n"
  81                "        .quad 1b,3b\n"
  82                ".previous"
  83                : "=&bDS" (err), "=a" (*eax), "=d" (*edx)
  84                : "c" (reg), "i" (-EIO), "0" (0));
  85
  86   return err;
  87 }
  88
  89 #ifdef CONFIG_SMP
  90
  91 struct msr_command {
  92   int cpu;
  93   int err;
  94   u32 reg;
  95   u32 data[2];
  96 };
  97
  98 static void msr_smp_wrmsr(void *cmd_block)
  99 {
 100   struct msr_command *cmd = (struct msr_command *) cmd_block;
 101
 102   if ( cmd->cpu == smp_processor_id() )
 103     cmd->err = wrmsr_eio(cmd->reg, cmd->data[0], cmd->data[1]);
 104 }
 105
 106 static void msr_smp_rdmsr(void *cmd_block)
 107 {
 108   struct msr_command *cmd = (struct msr_command *) cmd_block;
 109
 110   if ( cmd->cpu == smp_processor_id() )
 111     cmd->err = rdmsr_eio(cmd->reg, &cmd->data[0], &cmd->data[1]);
 112 }
 113
 114 static inline int do_wrmsr(int cpu, u32 reg, u32 eax, u32 edx)
 115 {
 116   struct msr_command cmd;
 117   int ret;
 118
 119   preempt_disable();
 120   if ( cpu == smp_processor_id() ) {
 121     ret = wrmsr_eio(reg, eax, edx);
 122   } else {
 123     cmd.cpu = cpu;
 124     cmd.reg = reg;
 125     cmd.data[0] = eax;
 126     cmd.data[1] = edx;
 127
 128     smp_call_function(msr_smp_wrmsr, &cmd, 1, 1);
 129     ret = cmd.err;
 130   }
 131   preempt_enable();
 132   return ret;
 133 }
 134
 135 static inline int do_rdmsr(int cpu, u32 reg, u32 *eax, u32 *edx)
 136 {
 137   struct msr_command cmd;
 138   int ret;
 139
 140   preempt_disable();
 141   if ( cpu == smp_processor_id() ) {
 142     ret = rdmsr_eio(reg, eax, edx);
 143   } else {
 144     cmd.cpu = cpu;
 145     cmd.reg = reg;
 146
 147     smp_call_function(msr_smp_rdmsr, &cmd, 1, 1);
 148
 149     *eax = cmd.data[0];
 150     *edx = cmd.data[1];
 151
 152     ret = cmd.err;
 153   }
 154   preempt_enable();
 155   return ret;
 156 }
 157
 158 #else /* ! CONFIG_SMP */
 159
 160 static inline int do_wrmsr(int cpu, u32 reg, u32 eax, u32 edx)
 161 {
 162   return wrmsr_eio(reg, eax, edx);
 163 }
 164
 165 static inline int do_rdmsr(int cpu, u32 reg, u32 *eax, u32 *edx)
 166 {
 167   return rdmsr_eio(reg, eax, edx);
 168 }
 169
 170 #endif /* ! CONFIG_SMP */
 171
 172 static loff_t msr_seek(struct file *file, loff_t offset, int orig)
 173 {
 174   loff_t ret = -EINVAL;
 175   lock_kernel();
 176   switch (orig) {
 177   case 0:
 178     file->f_pos = offset;
 179     ret = file->f_pos;
 180     break;
 181   case 1:
 182     file->f_pos += offset;
 183     ret = file->f_pos;
 184   }
 185   unlock_kernel();
 186   return ret;
 187 }
 188
 189 static ssize_t msr_read(struct file * file, char __user * buf,
 190                         size_t count, loff_t *ppos)
 191 {
 192   char __user *tmp = buf;
 193   u32 data[2];
 194   size_t rv;
 195   u32 reg = *ppos;
 196   int cpu = iminor(file->f_dentry->d_inode);
 197   int err;
 198
 199   if ( count % 8 )
 200     return -EINVAL; /* Invalid chunk size */
 201
 202   for ( rv = 0 ; count ; count -= 8 ) {
 203     err = do_rdmsr(cpu, reg, &data[0], &data[1]);
 204     if ( err )
 205       return err;
 206     if ( copy_to_user(tmp,&data,8) )
 207       return -EFAULT;
 208     tmp += 8;
 209   }
 210
 211   return tmp - buf;
 212 }
 213
 214 static ssize_t msr_write(struct file * file, const char __user * buf,
 215                          size_t count, loff_t *ppos)
 216 {
 217   const char __user *tmp = buf;
 218   u32 data[2];
 219   size_t rv;
 220   u32 reg = *ppos;
 221   int cpu = iminor(file->f_dentry->d_inode);
 222   int err;
 223
 224   if ( count % 8 )
 225     return -EINVAL; /* Invalid chunk size */
 226
 227   for ( rv = 0 ; count ; count -= 8 ) {
 228     if ( copy_from_user(&data,tmp,8) )
 229       return -EFAULT;
 230     err = do_wrmsr(cpu, reg, data[0], data[1]);
 231     if ( err )
 232       return err;
 233     tmp += 8;
 234   }
 235
 236   return tmp - buf;
 237 }
 238
 239 static int msr_open(struct inode *inode, struct file *file)
 240 {
 241   int cpu = iminor(file->f_dentry->d_inode);
 242   struct cpuinfo_x86 *c = &(cpu_data)[cpu];
 243
 244   if (cpu >= NR_CPUS || !cpu_online(cpu))
 245     return -ENXIO;              /* No such CPU */
 246   if ( !cpu_has(c, X86_FEATURE_MSR) )
 247     return -EIO;                /* MSR not supported */
 248
 249   return 0;
 250 }
 251
 252 /*
 253  * File operations we support
 254  */
 255 static struct file_operations msr_fops = {
 256   .owner =      THIS_MODULE,
 257   .llseek =     msr_seek,
 258   .read =       msr_read,
 259   .write =      msr_write,
 260   .open =       msr_open,
 261 };
 262
 263 int __init msr_init(void)
 264 {
 265   if (register_chrdev(MSR_MAJOR, "cpu/msr", &msr_fops)) {
 266     printk(KERN_ERR "msr: unable to get major %d for msr\n",
 267            MSR_MAJOR);
 268     return -EBUSY;
 269   }
 270
 271   return 0;
 272 }
 273
 274 void __exit msr_exit(void)
 275 {
 276   unregister_chrdev(MSR_MAJOR, "cpu/msr");
 277 }
 278
 279 module_init(msr_init);
 280 module_exit(msr_exit)
 281
 282 MODULE_AUTHOR("H. Peter Anvin <hpa@zytor.com>");
 283 MODULE_DESCRIPTION("x86 generic MSR driver");
 284 MODULE_LICENSE("GPL");