Merge master.kernel.org:/pub/scm/linux/kernel/git/davej/agpgart
[linux-2.6] / 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");