llseek: automatically add .llseek fop
[linux-2.6.git] / arch / sparc / kernel / apc.c
1 /* apc - Driver implementation for power management functions
2  * of Aurora Personality Chip (APC) on SPARCstation-4/5 and
3  * derivatives.
4  *
5  * Copyright (c) 2002 Eric Brower (ebrower@usa.net)
6  */
7
8 #include <linux/kernel.h>
9 #include <linux/fs.h>
10 #include <linux/errno.h>
11 #include <linux/init.h>
12 #include <linux/miscdevice.h>
13 #include <linux/pm.h>
14 #include <linux/of.h>
15 #include <linux/of_device.h>
16
17 #include <asm/io.h>
18 #include <asm/oplib.h>
19 #include <asm/uaccess.h>
20 #include <asm/auxio.h>
21 #include <asm/apc.h>
22
23 /* Debugging
24  * 
25  * #define APC_DEBUG_LED
26  */
27
28 #define APC_MINOR       MISC_DYNAMIC_MINOR
29 #define APC_OBPNAME     "power-management"
30 #define APC_DEVNAME "apc"
31
32 static u8 __iomem *regs;
33 static int apc_no_idle __devinitdata = 0;
34
35 #define apc_readb(offs)         (sbus_readb(regs+offs))
36 #define apc_writeb(val, offs)   (sbus_writeb(val, regs+offs))
37
38 /* Specify "apc=noidle" on the kernel command line to 
39  * disable APC CPU standby support.  Certain prototype
40  * systems (SPARCstation-Fox) do not play well with APC
41  * CPU idle, so disable this if your system has APC and 
42  * crashes randomly.
43  */
44 static int __init apc_setup(char *str) 
45 {
46         if(!strncmp(str, "noidle", strlen("noidle"))) {
47                 apc_no_idle = 1;
48                 return 1;
49         }
50         return 0;
51 }
52 __setup("apc=", apc_setup);
53
54 /* 
55  * CPU idle callback function
56  * See .../arch/sparc/kernel/process.c
57  */
58 static void apc_swift_idle(void)
59 {
60 #ifdef APC_DEBUG_LED
61         set_auxio(0x00, AUXIO_LED); 
62 #endif
63
64         apc_writeb(apc_readb(APC_IDLE_REG) | APC_IDLE_ON, APC_IDLE_REG);
65
66 #ifdef APC_DEBUG_LED
67         set_auxio(AUXIO_LED, 0x00); 
68 #endif
69
70
71 static inline void apc_free(struct platform_device *op)
72 {
73         of_iounmap(&op->resource[0], regs, resource_size(&op->resource[0]));
74 }
75
76 static int apc_open(struct inode *inode, struct file *f)
77 {
78         return 0;
79 }
80
81 static int apc_release(struct inode *inode, struct file *f)
82 {
83         return 0;
84 }
85
86 static long apc_ioctl(struct file *f, unsigned int cmd, unsigned long __arg)
87 {
88         __u8 inarg, __user *arg = (__u8 __user *) __arg;
89
90         switch (cmd) {
91         case APCIOCGFANCTL:
92                 if (put_user(apc_readb(APC_FANCTL_REG) & APC_REGMASK, arg))
93                         return -EFAULT;
94                 break;
95
96         case APCIOCGCPWR:
97                 if (put_user(apc_readb(APC_CPOWER_REG) & APC_REGMASK, arg))
98                         return -EFAULT;
99                 break;
100
101         case APCIOCGBPORT:
102                 if (put_user(apc_readb(APC_BPORT_REG) & APC_BPMASK, arg))
103                         return -EFAULT;
104                 break;
105
106         case APCIOCSFANCTL:
107                 if (get_user(inarg, arg))
108                         return -EFAULT;
109                 apc_writeb(inarg & APC_REGMASK, APC_FANCTL_REG);
110                 break;
111
112         case APCIOCSCPWR:
113                 if (get_user(inarg, arg))
114                         return -EFAULT;
115                 apc_writeb(inarg & APC_REGMASK, APC_CPOWER_REG);
116                 break;
117
118         case APCIOCSBPORT:
119                 if (get_user(inarg, arg))
120                         return -EFAULT;
121                 apc_writeb(inarg & APC_BPMASK, APC_BPORT_REG);
122                 break;
123
124         default:
125                 return -EINVAL;
126         };
127
128         return 0;
129 }
130
131 static const struct file_operations apc_fops = {
132         .unlocked_ioctl =       apc_ioctl,
133         .open =                 apc_open,
134         .release =              apc_release,
135         .llseek =               noop_llseek,
136 };
137
138 static struct miscdevice apc_miscdev = { APC_MINOR, APC_DEVNAME, &apc_fops };
139
140 static int __devinit apc_probe(struct platform_device *op,
141                                const struct of_device_id *match)
142 {
143         int err;
144
145         regs = of_ioremap(&op->resource[0], 0,
146                           resource_size(&op->resource[0]), APC_OBPNAME);
147         if (!regs) {
148                 printk(KERN_ERR "%s: unable to map registers\n", APC_DEVNAME);
149                 return -ENODEV;
150         }
151
152         err = misc_register(&apc_miscdev);
153         if (err) {
154                 printk(KERN_ERR "%s: unable to register device\n", APC_DEVNAME);
155                 apc_free(op);
156                 return -ENODEV;
157         }
158
159         /* Assign power management IDLE handler */
160         if (!apc_no_idle)
161                 pm_idle = apc_swift_idle;       
162
163         printk(KERN_INFO "%s: power management initialized%s\n", 
164                APC_DEVNAME, apc_no_idle ? " (CPU idle disabled)" : "");
165
166         return 0;
167 }
168
169 static struct of_device_id __initdata apc_match[] = {
170         {
171                 .name = APC_OBPNAME,
172         },
173         {},
174 };
175 MODULE_DEVICE_TABLE(of, apc_match);
176
177 static struct of_platform_driver apc_driver = {
178         .driver = {
179                 .name = "apc",
180                 .owner = THIS_MODULE,
181                 .of_match_table = apc_match,
182         },
183         .probe          = apc_probe,
184 };
185
186 static int __init apc_init(void)
187 {
188         return of_register_platform_driver(&apc_driver);
189 }
190
191 /* This driver is not critical to the boot process
192  * and is easiest to ioremap when SBus is already
193  * initialized, so we install ourselves thusly:
194  */
195 __initcall(apc_init);