ACPI: EC: make kernel messages more useful when GPE storm is detected
[linux-2.6] / drivers / char / ds1620.c
1 /*
2  * linux/drivers/char/ds1620.c: Dallas Semiconductors DS1620
3  *   thermometer driver (as used in the Rebel.com NetWinder)
4  */
5 #include <linux/module.h>
6 #include <linux/miscdevice.h>
7 #include <linux/delay.h>
8 #include <linux/proc_fs.h>
9 #include <linux/capability.h>
10 #include <linux/init.h>
11 #include <linux/smp_lock.h>
12
13 #include <mach/hardware.h>
14 #include <asm/mach-types.h>
15 #include <asm/uaccess.h>
16 #include <asm/therm.h>
17
18 #ifdef CONFIG_PROC_FS
19 /* define for /proc interface */
20 #define THERM_USE_PROC
21 #endif
22
23 /* Definitions for DS1620 chip */
24 #define THERM_START_CONVERT     0xee
25 #define THERM_RESET             0xaf
26 #define THERM_READ_CONFIG       0xac
27 #define THERM_READ_TEMP         0xaa
28 #define THERM_READ_TL           0xa2
29 #define THERM_READ_TH           0xa1
30 #define THERM_WRITE_CONFIG      0x0c
31 #define THERM_WRITE_TL          0x02
32 #define THERM_WRITE_TH          0x01
33
34 #define CFG_CPU                 2
35 #define CFG_1SHOT               1
36
37 static const char *fan_state[] = { "off", "on", "on (hardwired)" };
38
39 /*
40  * Start of NetWinder specifics
41  *  Note!  We have to hold the gpio lock with IRQs disabled over the
42  *  whole of our transaction to the Dallas chip, since there is a
43  *  chance that the WaveArtist driver could touch these bits to
44  *  enable or disable the speaker.
45  */
46 extern spinlock_t gpio_lock;
47 extern unsigned int system_rev;
48
49 static inline void netwinder_ds1620_set_clk(int clk)
50 {
51         gpio_modify_op(GPIO_DSCLK, clk ? GPIO_DSCLK : 0);
52 }
53
54 static inline void netwinder_ds1620_set_data(int dat)
55 {
56         gpio_modify_op(GPIO_DATA, dat ? GPIO_DATA : 0);
57 }
58
59 static inline int netwinder_ds1620_get_data(void)
60 {
61         return gpio_read() & GPIO_DATA;
62 }
63
64 static inline void netwinder_ds1620_set_data_dir(int dir)
65 {
66         gpio_modify_io(GPIO_DATA, dir ? GPIO_DATA : 0);
67 }
68
69 static inline void netwinder_ds1620_reset(void)
70 {
71         cpld_modify(CPLD_DS_ENABLE, 0);
72         cpld_modify(CPLD_DS_ENABLE, CPLD_DS_ENABLE);
73 }
74
75 static inline void netwinder_lock(unsigned long *flags)
76 {
77         spin_lock_irqsave(&gpio_lock, *flags);
78 }
79
80 static inline void netwinder_unlock(unsigned long *flags)
81 {
82         spin_unlock_irqrestore(&gpio_lock, *flags);
83 }
84
85 static inline void netwinder_set_fan(int i)
86 {
87         unsigned long flags;
88
89         spin_lock_irqsave(&gpio_lock, flags);
90         gpio_modify_op(GPIO_FAN, i ? GPIO_FAN : 0);
91         spin_unlock_irqrestore(&gpio_lock, flags);
92 }
93
94 static inline int netwinder_get_fan(void)
95 {
96         if ((system_rev & 0xf000) == 0x4000)
97                 return FAN_ALWAYS_ON;
98
99         return (gpio_read() & GPIO_FAN) ? FAN_ON : FAN_OFF;
100 }
101
102 /*
103  * End of NetWinder specifics
104  */
105
106 static void ds1620_send_bits(int nr, int value)
107 {
108         int i;
109
110         for (i = 0; i < nr; i++) {
111                 netwinder_ds1620_set_data(value & 1);
112                 netwinder_ds1620_set_clk(0);
113                 udelay(1);
114                 netwinder_ds1620_set_clk(1);
115                 udelay(1);
116
117                 value >>= 1;
118         }
119 }
120
121 static unsigned int ds1620_recv_bits(int nr)
122 {
123         unsigned int value = 0, mask = 1;
124         int i;
125
126         netwinder_ds1620_set_data(0);
127
128         for (i = 0; i < nr; i++) {
129                 netwinder_ds1620_set_clk(0);
130                 udelay(1);
131
132                 if (netwinder_ds1620_get_data())
133                         value |= mask;
134
135                 mask <<= 1;
136
137                 netwinder_ds1620_set_clk(1);
138                 udelay(1);
139         }
140
141         return value;
142 }
143
144 static void ds1620_out(int cmd, int bits, int value)
145 {
146         unsigned long flags;
147
148         netwinder_lock(&flags);
149         netwinder_ds1620_set_clk(1);
150         netwinder_ds1620_set_data_dir(0);
151         netwinder_ds1620_reset();
152
153         udelay(1);
154
155         ds1620_send_bits(8, cmd);
156         if (bits)
157                 ds1620_send_bits(bits, value);
158
159         udelay(1);
160
161         netwinder_ds1620_reset();
162         netwinder_unlock(&flags);
163
164         msleep(20);
165 }
166
167 static unsigned int ds1620_in(int cmd, int bits)
168 {
169         unsigned long flags;
170         unsigned int value;
171
172         netwinder_lock(&flags);
173         netwinder_ds1620_set_clk(1);
174         netwinder_ds1620_set_data_dir(0);
175         netwinder_ds1620_reset();
176
177         udelay(1);
178
179         ds1620_send_bits(8, cmd);
180
181         netwinder_ds1620_set_data_dir(1);
182         value = ds1620_recv_bits(bits);
183
184         netwinder_ds1620_reset();
185         netwinder_unlock(&flags);
186
187         return value;
188 }
189
190 static int cvt_9_to_int(unsigned int val)
191 {
192         if (val & 0x100)
193                 val |= 0xfffffe00;
194
195         return val;
196 }
197
198 static void ds1620_write_state(struct therm *therm)
199 {
200         ds1620_out(THERM_WRITE_CONFIG, 8, CFG_CPU);
201         ds1620_out(THERM_WRITE_TL, 9, therm->lo);
202         ds1620_out(THERM_WRITE_TH, 9, therm->hi);
203         ds1620_out(THERM_START_CONVERT, 0, 0);
204 }
205
206 static void ds1620_read_state(struct therm *therm)
207 {
208         therm->lo = cvt_9_to_int(ds1620_in(THERM_READ_TL, 9));
209         therm->hi = cvt_9_to_int(ds1620_in(THERM_READ_TH, 9));
210 }
211
212 static int ds1620_open(struct inode *inode, struct file *file)
213 {
214         cycle_kernel_lock();
215         return nonseekable_open(inode, file);
216 }
217
218 static ssize_t
219 ds1620_read(struct file *file, char __user *buf, size_t count, loff_t *ptr)
220 {
221         signed int cur_temp;
222         signed char cur_temp_degF;
223
224         cur_temp = cvt_9_to_int(ds1620_in(THERM_READ_TEMP, 9)) >> 1;
225
226         /* convert to Fahrenheit, as per wdt.c */
227         cur_temp_degF = (cur_temp * 9) / 5 + 32;
228
229         if (copy_to_user(buf, &cur_temp_degF, 1))
230                 return -EFAULT;
231
232         return 1;
233 }
234
235 static int
236 ds1620_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
237 {
238         struct therm therm;
239         union {
240                 struct therm __user *therm;
241                 int __user *i;
242         } uarg;
243         int i;
244
245         uarg.i = (int __user *)arg;
246
247         switch(cmd) {
248         case CMD_SET_THERMOSTATE:
249         case CMD_SET_THERMOSTATE2:
250                 if (!capable(CAP_SYS_ADMIN))
251                         return -EPERM;
252
253                 if (cmd == CMD_SET_THERMOSTATE) {
254                         if (get_user(therm.hi, uarg.i))
255                                 return -EFAULT;
256                         therm.lo = therm.hi - 3;
257                 } else {
258                         if (copy_from_user(&therm, uarg.therm, sizeof(therm)))
259                                 return -EFAULT;
260                 }
261
262                 therm.lo <<= 1;
263                 therm.hi <<= 1;
264
265                 ds1620_write_state(&therm);
266                 break;
267
268         case CMD_GET_THERMOSTATE:
269         case CMD_GET_THERMOSTATE2:
270                 ds1620_read_state(&therm);
271
272                 therm.lo >>= 1;
273                 therm.hi >>= 1;
274
275                 if (cmd == CMD_GET_THERMOSTATE) {
276                         if (put_user(therm.hi, uarg.i))
277                                 return -EFAULT;
278                 } else {
279                         if (copy_to_user(uarg.therm, &therm, sizeof(therm)))
280                                 return -EFAULT;
281                 }
282                 break;
283
284         case CMD_GET_TEMPERATURE:
285         case CMD_GET_TEMPERATURE2:
286                 i = cvt_9_to_int(ds1620_in(THERM_READ_TEMP, 9));
287
288                 if (cmd == CMD_GET_TEMPERATURE)
289                         i >>= 1;
290
291                 return put_user(i, uarg.i) ? -EFAULT : 0;
292
293         case CMD_GET_STATUS:
294                 i = ds1620_in(THERM_READ_CONFIG, 8) & 0xe3;
295
296                 return put_user(i, uarg.i) ? -EFAULT : 0;
297
298         case CMD_GET_FAN:
299                 i = netwinder_get_fan();
300
301                 return put_user(i, uarg.i) ? -EFAULT : 0;
302
303         case CMD_SET_FAN:
304                 if (!capable(CAP_SYS_ADMIN))
305                         return -EPERM;
306
307                 if (get_user(i, uarg.i))
308                         return -EFAULT;
309
310                 netwinder_set_fan(i);
311                 break;
312                 
313         default:
314                 return -ENOIOCTLCMD;
315         }
316
317         return 0;
318 }
319
320 #ifdef THERM_USE_PROC
321 static int
322 proc_therm_ds1620_read(char *buf, char **start, off_t offset,
323                        int len, int *eof, void *unused)
324 {
325         struct therm th;
326         int temp;
327
328         ds1620_read_state(&th);
329         temp =  cvt_9_to_int(ds1620_in(THERM_READ_TEMP, 9));
330
331         len = sprintf(buf, "Thermostat: HI %i.%i, LOW %i.%i; "
332                       "temperature: %i.%i C, fan %s\n",
333                       th.hi >> 1, th.hi & 1 ? 5 : 0,
334                       th.lo >> 1, th.lo & 1 ? 5 : 0,
335                       temp  >> 1, temp  & 1 ? 5 : 0,
336                       fan_state[netwinder_get_fan()]);
337
338         return len;
339 }
340
341 static struct proc_dir_entry *proc_therm_ds1620;
342 #endif
343
344 static const struct file_operations ds1620_fops = {
345         .owner          = THIS_MODULE,
346         .open           = ds1620_open,
347         .read           = ds1620_read,
348         .ioctl          = ds1620_ioctl,
349 };
350
351 static struct miscdevice ds1620_miscdev = {
352         TEMP_MINOR,
353         "temp",
354         &ds1620_fops
355 };
356
357 static int __init ds1620_init(void)
358 {
359         int ret;
360         struct therm th, th_start;
361
362         if (!machine_is_netwinder())
363                 return -ENODEV;
364
365         ds1620_out(THERM_RESET, 0, 0);
366         ds1620_out(THERM_WRITE_CONFIG, 8, CFG_CPU);
367         ds1620_out(THERM_START_CONVERT, 0, 0);
368
369         /*
370          * Trigger the fan to start by setting
371          * temperature high point low.  This kicks
372          * the fan into action.
373          */
374         ds1620_read_state(&th);
375         th_start.lo = 0;
376         th_start.hi = 1;
377         ds1620_write_state(&th_start);
378
379         msleep(2000);
380
381         ds1620_write_state(&th);
382
383         ret = misc_register(&ds1620_miscdev);
384         if (ret < 0)
385                 return ret;
386
387 #ifdef THERM_USE_PROC
388         proc_therm_ds1620 = create_proc_entry("therm", 0, NULL);
389         if (proc_therm_ds1620)
390                 proc_therm_ds1620->read_proc = proc_therm_ds1620_read;
391         else
392                 printk(KERN_ERR "therm: unable to register /proc/therm\n");
393 #endif
394
395         ds1620_read_state(&th);
396         ret = cvt_9_to_int(ds1620_in(THERM_READ_TEMP, 9));
397
398         printk(KERN_INFO "Thermostat: high %i.%i, low %i.%i, "
399                "current %i.%i C, fan %s.\n",
400                th.hi >> 1, th.hi & 1 ? 5 : 0,
401                th.lo >> 1, th.lo & 1 ? 5 : 0,
402                ret   >> 1, ret   & 1 ? 5 : 0,
403                fan_state[netwinder_get_fan()]);
404
405         return 0;
406 }
407
408 static void __exit ds1620_exit(void)
409 {
410 #ifdef THERM_USE_PROC
411         remove_proc_entry("therm", NULL);
412 #endif
413         misc_deregister(&ds1620_miscdev);
414 }
415
416 module_init(ds1620_init);
417 module_exit(ds1620_exit);
418
419 MODULE_LICENSE("GPL");