drivers/misc/hdpuftrs/hdpu_cpustate.c

   1 /*
   2  *      Sky CPU State Driver
   3  *
   4  *      Copyright (C) 2002 Brian Waite
   5  *
   6  *      This driver allows use of the CPU state bits
   7  *      It exports the /dev/sky_cpustate and also
   8  *      /proc/sky_cpustate pseudo-file for status information.
   9  *
  10  *      This program is free software; you can redistribute it and/or
  11  *      modify it under the terms of the GNU General Public License
  12  *      as published by the Free Software Foundation; either version
  13  *      2 of the License, or (at your option) any later version.
  14  *
  15  */
  16
  17 #include <linux/version.h>
  18 #include <linux/module.h>
  19 #include <linux/kernel.h>
  20 #include <linux/spinlock.h>
  21 #include <linux/miscdevice.h>
  22 #include <linux/pci.h>
  23 #include <linux/proc_fs.h>
  24 #include <linux/platform_device.h>
  25 #include <asm/uaccess.h>
  26 #include <linux/hdpu_features.h>
  27
  28 #define SKY_CPUSTATE_VERSION            "1.1"
  29
  30 static int hdpu_cpustate_probe(struct device *ddev);
  31 static int hdpu_cpustate_remove(struct device *ddev);
  32
  33 struct cpustate_t cpustate;
  34
  35 static int cpustate_get_ref(int excl)
  36 {
  37
  38         int retval = -EBUSY;
  39
  40         spin_lock(&cpustate.lock);
  41
  42         if (cpustate.excl)
  43                 goto out_busy;
  44
  45         if (excl) {
  46                 if (cpustate.open_count)
  47                         goto out_busy;
  48                 cpustate.excl = 1;
  49         }
  50
  51         cpustate.open_count++;
  52         retval = 0;
  53
  54       out_busy:
  55         spin_unlock(&cpustate.lock);
  56         return retval;
  57 }
  58
  59 static int cpustate_free_ref(void)
  60 {
  61
  62         spin_lock(&cpustate.lock);
  63
  64         cpustate.excl = 0;
  65         cpustate.open_count--;
  66
  67         spin_unlock(&cpustate.lock);
  68         return 0;
  69 }
  70
  71 unsigned char cpustate_get_state(void)
  72 {
  73
  74         return cpustate.cached_val;
  75 }
  76
  77 void cpustate_set_state(unsigned char new_state)
  78 {
  79         unsigned int state = (new_state << 21);
  80
  81 #ifdef DEBUG_CPUSTATE
  82         printk("CPUSTATE -> 0x%x\n", new_state);
  83 #endif
  84         spin_lock(&cpustate.lock);
  85         cpustate.cached_val = new_state;
  86         writel((0xff << 21), cpustate.clr_addr);
  87         writel(state, cpustate.set_addr);
  88         spin_unlock(&cpustate.lock);
  89 }
  90
  91 /*
  92  *      Now all the various file operations that we export.
  93  */
  94
  95 static ssize_t cpustate_read(struct file *file, char *buf,
  96                              size_t count, loff_t * ppos)
  97 {
  98         unsigned char data;
  99
 100         if (count < 0)
 101                 return -EFAULT;
 102         if (count == 0)
 103                 return 0;
 104
 105         data = cpustate_get_state();
 106         if (copy_to_user(buf, &data, sizeof(unsigned char)))
 107                 return -EFAULT;
 108         return sizeof(unsigned char);
 109 }
 110
 111 static ssize_t cpustate_write(struct file *file, const char *buf,
 112                               size_t count, loff_t * ppos)
 113 {
 114         unsigned char data;
 115
 116         if (count < 0)
 117                 return -EFAULT;
 118
 119         if (count == 0)
 120                 return 0;
 121
 122         if (copy_from_user((unsigned char *)&data, buf, sizeof(unsigned char)))
 123                 return -EFAULT;
 124
 125         cpustate_set_state(data);
 126         return sizeof(unsigned char);
 127 }
 128
 129 static int cpustate_open(struct inode *inode, struct file *file)
 130 {
 131         return cpustate_get_ref((file->f_flags & O_EXCL));
 132 }
 133
 134 static int cpustate_release(struct inode *inode, struct file *file)
 135 {
 136         return cpustate_free_ref();
 137 }
 138
 139 /*
 140  *      Info exported via "/proc/sky_cpustate".
 141  */
 142 static int cpustate_read_proc(char *page, char **start, off_t off,
 143                               int count, int *eof, void *data)
 144 {
 145         char *p = page;
 146         int len = 0;
 147
 148         p += sprintf(p, "CPU State: %04x\n", cpustate_get_state());
 149         len = p - page;
 150
 151         if (len <= off + count)
 152                 *eof = 1;
 153         *start = page + off;
 154         len -= off;
 155         if (len > count)
 156                 len = count;
 157         if (len < 0)
 158                 len = 0;
 159         return len;
 160 }
 161
 162 static struct device_driver hdpu_cpustate_driver = {
 163         .name = HDPU_CPUSTATE_NAME,
 164         .bus = &platform_bus_type,
 165         .probe = hdpu_cpustate_probe,
 166         .remove = hdpu_cpustate_remove,
 167 };
 168
 169 /*
 170  *      The various file operations we support.
 171  */
 172 static struct file_operations cpustate_fops = {
 173       owner:THIS_MODULE,
 174       open:cpustate_open,
 175       release:cpustate_release,
 176       read:cpustate_read,
 177       write:cpustate_write,
 178       fasync:NULL,
 179       poll:NULL,
 180       ioctl:NULL,
 181       llseek:no_llseek,
 182
 183 };
 184
 185 static struct miscdevice cpustate_dev = {
 186         MISC_DYNAMIC_MINOR,
 187         "sky_cpustate",
 188         &cpustate_fops
 189 };
 190
 191 static int hdpu_cpustate_probe(struct device *ddev)
 192 {
 193         struct platform_device *pdev = to_platform_device(ddev);
 194         struct resource *res;
 195         struct proc_dir_entry *proc_de;
 196         int ret;
 197
 198         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 199         cpustate.set_addr = (unsigned long *)res->start;
 200         cpustate.clr_addr = (unsigned long *)res->end - 1;
 201
 202         ret = misc_register(&cpustate_dev);
 203         if (ret) {
 204                 printk(KERN_WARNING "sky_cpustate: Unable to register misc "
 205                                         "device.\n");
 206                 cpustate.set_addr = NULL;
 207                 cpustate.clr_addr = NULL;
 208                 return ret;
 209         }
 210
 211         proc_de = create_proc_read_entry("sky_cpustate", 0, 0,
 212                                         cpustate_read_proc, NULL);
 213         if (proc_de == NULL)
 214                 printk(KERN_WARNING "sky_cpustate: Unable to create proc "
 215                                         "dir entry\n");
 216
 217         printk(KERN_INFO "Sky CPU State Driver v" SKY_CPUSTATE_VERSION "\n");
 218         return 0;
 219 }
 220
 221 static int hdpu_cpustate_remove(struct device *ddev)
 222 {
 223
 224         cpustate.set_addr = NULL;
 225         cpustate.clr_addr = NULL;
 226
 227         remove_proc_entry("sky_cpustate", NULL);
 228         misc_deregister(&cpustate_dev);
 229         return 0;
 230
 231 }
 232
 233 static int __init cpustate_init(void)
 234 {
 235         int rc;
 236         rc = driver_register(&hdpu_cpustate_driver);
 237         return rc;
 238 }
 239
 240 static void __exit cpustate_exit(void)
 241 {
 242         driver_unregister(&hdpu_cpustate_driver);
 243 }
 244
 245 module_init(cpustate_init);
 246 module_exit(cpustate_exit);
 247
 248 MODULE_AUTHOR("Brian Waite");
 249 MODULE_LICENSE("GPL");