URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [char/] [ds1620.c] - Blame information for rev 62

Details | Compare with Previous | View Log


/*
 * linux/drivers/char/ds1620.c: Dallas Semiconductors DS1620
 *   thermometer driver (as used in the Rebel.com NetWinder)
 */
#include <linux/module.h>
#include <linux/miscdevice.h>
#include <linux/delay.h>
#include <linux/proc_fs.h>
#include <linux/capability.h>
#include <linux/init.h>
 
#include <asm/hardware.h>
#include <asm/mach-types.h>
#include <asm/uaccess.h>
#include <asm/therm.h>
 
#ifdef CONFIG_PROC_FS
/* define for /proc interface */
#define THERM_USE_PROC
#endif
 
/* Definitions for DS1620 chip */
#define THERM_START_CONVERT     0xee
#define THERM_RESET             0xaf
#define THERM_READ_CONFIG       0xac
#define THERM_READ_TEMP         0xaa
#define THERM_READ_TL           0xa2
#define THERM_READ_TH           0xa1
#define THERM_WRITE_CONFIG      0x0c
#define THERM_WRITE_TL          0x02
#define THERM_WRITE_TH          0x01
 
#define CFG_CPU                 2
#define CFG_1SHOT               1
 
static const char *fan_state[] = { "off", "on", "on (hardwired)" };
 
/*
 * Start of NetWinder specifics
 *  Note!  We have to hold the gpio lock with IRQs disabled over the
 *  whole of our transaction to the Dallas chip, since there is a
 *  chance that the WaveArtist driver could touch these bits to
 *  enable or disable the speaker.
 */
extern spinlock_t gpio_lock;
extern unsigned int system_rev;
 
static inline void netwinder_ds1620_set_clk(int clk)
{
        gpio_modify_op(GPIO_DSCLK, clk ? GPIO_DSCLK : 0);
}
 
static inline void netwinder_ds1620_set_data(int dat)
{
        gpio_modify_op(GPIO_DATA, dat ? GPIO_DATA : 0);
}
 
static inline int netwinder_ds1620_get_data(void)
{
        return gpio_read() & GPIO_DATA;
}
 
static inline void netwinder_ds1620_set_data_dir(int dir)
{
        gpio_modify_io(GPIO_DATA, dir ? GPIO_DATA : 0);
}
 
static inline void netwinder_ds1620_reset(void)
{
        cpld_modify(CPLD_DS_ENABLE, 0);
        cpld_modify(CPLD_DS_ENABLE, CPLD_DS_ENABLE);
}
 
static inline void netwinder_lock(unsigned long *flags)
{
        spin_lock_irqsave(&gpio_lock, *flags);
}
 
static inline void netwinder_unlock(unsigned long *flags)
{
        spin_unlock_irqrestore(&gpio_lock, *flags);
}
 
static inline void netwinder_set_fan(int i)
{
        unsigned long flags;
 
        spin_lock_irqsave(&gpio_lock, flags);
        gpio_modify_op(GPIO_FAN, i ? GPIO_FAN : 0);
        spin_unlock_irqrestore(&gpio_lock, flags);
}
 
static inline int netwinder_get_fan(void)
{
        if ((system_rev & 0xf000) == 0x4000)
                return FAN_ALWAYS_ON;
 
        return (gpio_read() & GPIO_FAN) ? FAN_ON : FAN_OFF;
}
 
/*
 * End of NetWinder specifics
 */
 
static void ds1620_send_bits(int nr, int value)
{
        int i;
 
        for (i = 0; i < nr; i++) {
                netwinder_ds1620_set_data(value & 1);
                netwinder_ds1620_set_clk(0);
                udelay(1);
                netwinder_ds1620_set_clk(1);
                udelay(1);
 
                value >>= 1;
        }
}
 
static unsigned int ds1620_recv_bits(int nr)
{
        unsigned int value = 0, mask = 1;
        int i;
 
        netwinder_ds1620_set_data(0);
 
        for (i = 0; i < nr; i++) {
                netwinder_ds1620_set_clk(0);
                udelay(1);
 
                if (netwinder_ds1620_get_data())
                        value |= mask;
 
                mask <<= 1;
 
                netwinder_ds1620_set_clk(1);
                udelay(1);
        }
 
        return value;
}
 
static void ds1620_out(int cmd, int bits, int value)
{
        unsigned long flags;
 
        netwinder_lock(&flags);
        netwinder_ds1620_set_clk(1);
        netwinder_ds1620_set_data_dir(0);
        netwinder_ds1620_reset();
 
        udelay(1);
 
        ds1620_send_bits(8, cmd);
        if (bits)
                ds1620_send_bits(bits, value);
 
        udelay(1);
 
        netwinder_ds1620_reset();
        netwinder_unlock(&flags);
 
        msleep(20);
}
 
static unsigned int ds1620_in(int cmd, int bits)
{
        unsigned long flags;
        unsigned int value;
 
        netwinder_lock(&flags);
        netwinder_ds1620_set_clk(1);
        netwinder_ds1620_set_data_dir(0);
        netwinder_ds1620_reset();
 
        udelay(1);
 
        ds1620_send_bits(8, cmd);
 
        netwinder_ds1620_set_data_dir(1);
        value = ds1620_recv_bits(bits);
 
        netwinder_ds1620_reset();
        netwinder_unlock(&flags);
 
        return value;
}
 
static int cvt_9_to_int(unsigned int val)
{
        if (val & 0x100)
                val |= 0xfffffe00;
 
        return val;
}
 
static void ds1620_write_state(struct therm *therm)
{
        ds1620_out(THERM_WRITE_CONFIG, 8, CFG_CPU);
        ds1620_out(THERM_WRITE_TL, 9, therm->lo);
        ds1620_out(THERM_WRITE_TH, 9, therm->hi);
        ds1620_out(THERM_START_CONVERT, 0, 0);
}
 
static void ds1620_read_state(struct therm *therm)
{
        therm->lo = cvt_9_to_int(ds1620_in(THERM_READ_TL, 9));
        therm->hi = cvt_9_to_int(ds1620_in(THERM_READ_TH, 9));
}
 
static ssize_t
ds1620_read(struct file *file, char __user *buf, size_t count, loff_t *ptr)
{
        signed int cur_temp;
        signed char cur_temp_degF;
 
        cur_temp = cvt_9_to_int(ds1620_in(THERM_READ_TEMP, 9)) >> 1;
 
        /* convert to Fahrenheit, as per wdt.c */
        cur_temp_degF = (cur_temp * 9) / 5 + 32;
 
        if (copy_to_user(buf, &cur_temp_degF, 1))
                return -EFAULT;
 
        return 1;
}
 
static int
ds1620_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
{
        struct therm therm;
        union {
                struct therm __user *therm;
                int __user *i;
        } uarg;
        int i;
 
        uarg.i = (int __user *)arg;
 
        switch(cmd) {
        case CMD_SET_THERMOSTATE:
        case CMD_SET_THERMOSTATE2:
                if (!capable(CAP_SYS_ADMIN))
                        return -EPERM;
 
                if (cmd == CMD_SET_THERMOSTATE) {
                        if (get_user(therm.hi, uarg.i))
                                return -EFAULT;
                        therm.lo = therm.hi - 3;
                } else {
                        if (copy_from_user(&therm, uarg.therm, sizeof(therm)))
                                return -EFAULT;
                }
 
                therm.lo <<= 1;
                therm.hi <<= 1;
 
                ds1620_write_state(&therm);
                break;
 
        case CMD_GET_THERMOSTATE:
        case CMD_GET_THERMOSTATE2:
                ds1620_read_state(&therm);
 
                therm.lo >>= 1;
                therm.hi >>= 1;
 
                if (cmd == CMD_GET_THERMOSTATE) {
                        if (put_user(therm.hi, uarg.i))
                                return -EFAULT;
                } else {
                        if (copy_to_user(uarg.therm, &therm, sizeof(therm)))
                                return -EFAULT;
                }
                break;
 
        case CMD_GET_TEMPERATURE:
        case CMD_GET_TEMPERATURE2:
                i = cvt_9_to_int(ds1620_in(THERM_READ_TEMP, 9));
 
                if (cmd == CMD_GET_TEMPERATURE)
                        i >>= 1;
 
                return put_user(i, uarg.i) ? -EFAULT : 0;
 
        case CMD_GET_STATUS:
                i = ds1620_in(THERM_READ_CONFIG, 8) & 0xe3;
 
                return put_user(i, uarg.i) ? -EFAULT : 0;
 
        case CMD_GET_FAN:
                i = netwinder_get_fan();
 
                return put_user(i, uarg.i) ? -EFAULT : 0;
 
        case CMD_SET_FAN:
                if (!capable(CAP_SYS_ADMIN))
                        return -EPERM;
 
                if (get_user(i, uarg.i))
                        return -EFAULT;
 
                netwinder_set_fan(i);
                break;
 
        default:
                return -ENOIOCTLCMD;
        }
 
        return 0;
}
 
#ifdef THERM_USE_PROC
static int
proc_therm_ds1620_read(char *buf, char **start, off_t offset,
                       int len, int *eof, void *unused)
{
        struct therm th;
        int temp;
 
        ds1620_read_state(&th);
        temp =  cvt_9_to_int(ds1620_in(THERM_READ_TEMP, 9));
 
        len = sprintf(buf, "Thermostat: HI %i.%i, LOW %i.%i; "
                      "temperature: %i.%i C, fan %s\n",
                      th.hi >> 1, th.hi & 1 ? 5 : 0,
                      th.lo >> 1, th.lo & 1 ? 5 : 0,
                      temp  >> 1, temp  & 1 ? 5 : 0,
                      fan_state[netwinder_get_fan()]);
 
        return len;
}
 
static struct proc_dir_entry *proc_therm_ds1620;
#endif
 
static const struct file_operations ds1620_fops = {
        .owner          = THIS_MODULE,
        .open           = nonseekable_open,
        .read           = ds1620_read,
        .ioctl          = ds1620_ioctl,
};
 
static struct miscdevice ds1620_miscdev = {
        TEMP_MINOR,
        "temp",
        &ds1620_fops
};
 
static int __init ds1620_init(void)
{
        int ret;
        struct therm th, th_start;
 
        if (!machine_is_netwinder())
                return -ENODEV;
 
        ds1620_out(THERM_RESET, 0, 0);
        ds1620_out(THERM_WRITE_CONFIG, 8, CFG_CPU);
        ds1620_out(THERM_START_CONVERT, 0, 0);
 
        /*
         * Trigger the fan to start by setting
         * temperature high point low.  This kicks
         * the fan into action.
         */
        ds1620_read_state(&th);
        th_start.lo = 0;
        th_start.hi = 1;
        ds1620_write_state(&th_start);
 
        msleep(2000);
 
        ds1620_write_state(&th);
 
        ret = misc_register(&ds1620_miscdev);
        if (ret < 0)
                return ret;
 
#ifdef THERM_USE_PROC
        proc_therm_ds1620 = create_proc_entry("therm", 0, NULL);
        if (proc_therm_ds1620)
                proc_therm_ds1620->read_proc = proc_therm_ds1620_read;
        else
                printk(KERN_ERR "therm: unable to register /proc/therm\n");
#endif
 
        ds1620_read_state(&th);
        ret = cvt_9_to_int(ds1620_in(THERM_READ_TEMP, 9));
 
        printk(KERN_INFO "Thermostat: high %i.%i, low %i.%i, "
               "current %i.%i C, fan %s.\n",
               th.hi >> 1, th.hi & 1 ? 5 : 0,
               th.lo >> 1, th.lo & 1 ? 5 : 0,
               ret   >> 1, ret   & 1 ? 5 : 0,
               fan_state[netwinder_get_fan()]);
 
        return 0;
}
 
static void __exit ds1620_exit(void)
{
#ifdef THERM_USE_PROC
        remove_proc_entry("therm", NULL);
#endif
        misc_deregister(&ds1620_miscdev);
}
 
module_init(ds1620_init);
module_exit(ds1620_exit);
 
MODULE_LICENSE("GPL");

Browse

Tools

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [char/] [ds1620.c] - Blame information for rev 62

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