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

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [macintosh/] [therm_adt746x.c] - Blame information for rev 62

Details | Compare with Previous | View Log


/*
 * Device driver for the i2c thermostat found on the iBook G4, Albook G4
 *
 * Copyright (C) 2003, 2004 Colin Leroy, Rasmus Rohde, Benjamin Herrenschmidt
 *
 * Documentation from
 * http://www.analog.com/UploadedFiles/Data_Sheets/115254175ADT7467_pra.pdf
 * http://www.analog.com/UploadedFiles/Data_Sheets/3686221171167ADT7460_b.pdf
 *
 */
 
#include <linux/types.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/sched.h>
#include <linux/i2c.h>
#include <linux/slab.h>
#include <linux/init.h>
#include <linux/spinlock.h>
#include <linux/wait.h>
#include <linux/suspend.h>
#include <linux/kthread.h>
#include <linux/moduleparam.h>
#include <linux/freezer.h>
 
#include <asm/prom.h>
#include <asm/machdep.h>
#include <asm/io.h>
#include <asm/system.h>
#include <asm/sections.h>
#include <asm/of_platform.h>
 
#undef DEBUG
 
#define CONFIG_REG   0x40
#define MANUAL_MASK  0xe0
#define AUTO_MASK    0x20
 
static u8 TEMP_REG[3]    = {0x26, 0x25, 0x27}; /* local, sensor1, sensor2 */
static u8 LIMIT_REG[3]   = {0x6b, 0x6a, 0x6c}; /* local, sensor1, sensor2 */
static u8 MANUAL_MODE[2] = {0x5c, 0x5d};
static u8 REM_CONTROL[2] = {0x00, 0x40};
static u8 FAN_SPEED[2]   = {0x28, 0x2a};
static u8 FAN_SPD_SET[2] = {0x30, 0x31};
 
static u8 default_limits_local[3] = {70, 50, 70};    /* local, sensor1, sensor2 */
static u8 default_limits_chip[3] = {80, 65, 80};    /* local, sensor1, sensor2 */
static const char *sensor_location[3];
 
static int limit_adjust;
static int fan_speed = -1;
static int verbose;
 
MODULE_AUTHOR("Colin Leroy <colin@colino.net>");
MODULE_DESCRIPTION("Driver for ADT746x thermostat in iBook G4 and "
                   "Powerbook G4 Alu");
MODULE_LICENSE("GPL");
 
module_param(limit_adjust, int, 0644);
MODULE_PARM_DESC(limit_adjust,"Adjust maximum temperatures (50 sensor1, 70 sensor2) "
                 "by N degrees.");
 
module_param(fan_speed, int, 0644);
MODULE_PARM_DESC(fan_speed,"Specify starting fan speed (0-255) "
                 "(default 64)");
 
module_param(verbose, bool, 0);
MODULE_PARM_DESC(verbose,"Verbose log operations "
                 "(default 0)");
 
struct thermostat {
        struct i2c_client       clt;
        u8                      temps[3];
        u8                      cached_temp[3];
        u8                      initial_limits[3];
        u8                      limits[3];
        int                     last_speed[2];
        int                     last_var[2];
};
 
static enum {ADT7460, ADT7467} therm_type;
static int therm_bus, therm_address;
static struct of_device * of_dev;
static struct thermostat* thermostat;
static struct task_struct *thread_therm = NULL;
 
static int attach_one_thermostat(struct i2c_adapter *adapter, int addr,
                                 int busno);
 
static void write_both_fan_speed(struct thermostat *th, int speed);
static void write_fan_speed(struct thermostat *th, int speed, int fan);
 
static int
write_reg(struct thermostat* th, int reg, u8 data)
{
        u8 tmp[2];
        int rc;
 
        tmp[0] = reg;
        tmp[1] = data;
        rc = i2c_master_send(&th->clt, (const char *)tmp, 2);
        if (rc < 0)
                return rc;
        if (rc != 2)
                return -ENODEV;
        return 0;
}
 
static int
read_reg(struct thermostat* th, int reg)
{
        u8 reg_addr, data;
        int rc;
 
        reg_addr = (u8)reg;
        rc = i2c_master_send(&th->clt, &reg_addr, 1);
        if (rc < 0)
                return rc;
        if (rc != 1)
                return -ENODEV;
        rc = i2c_master_recv(&th->clt, (char *)&data, 1);
        if (rc < 0)
                return rc;
        return data;
}
 
static int
attach_thermostat(struct i2c_adapter *adapter)
{
        unsigned long bus_no;
 
        if (strncmp(adapter->name, "uni-n", 5))
                return -ENODEV;
        bus_no = simple_strtoul(adapter->name + 6, NULL, 10);
        if (bus_no != therm_bus)
                return -ENODEV;
        return attach_one_thermostat(adapter, therm_address, bus_no);
}
 
static int
detach_thermostat(struct i2c_adapter *adapter)
{
        struct thermostat* th;
        int i;
 
        if (thermostat == NULL)
                return 0;
 
        th = thermostat;
 
        if (thread_therm != NULL) {
                kthread_stop(thread_therm);
        }
 
        printk(KERN_INFO "adt746x: Putting max temperatures back from "
                         "%d, %d, %d to %d, %d, %d\n",
                th->limits[0], th->limits[1], th->limits[2],
                th->initial_limits[0], th->initial_limits[1],
                th->initial_limits[2]);
 
        for (i = 0; i < 3; i++)
                write_reg(th, LIMIT_REG[i], th->initial_limits[i]);
 
        write_both_fan_speed(th, -1);
 
        i2c_detach_client(&th->clt);
 
        thermostat = NULL;
 
        kfree(th);
 
        return 0;
}
 
static struct i2c_driver thermostat_driver = {
        .driver = {
                .name   = "therm_adt746x",
        },
        .attach_adapter = attach_thermostat,
        .detach_adapter = detach_thermostat,
};
 
static int read_fan_speed(struct thermostat *th, u8 addr)
{
        u8 tmp[2];
        u16 res;
 
        /* should start with low byte */
        tmp[1] = read_reg(th, addr);
        tmp[0] = read_reg(th, addr + 1);
 
        res = tmp[1] + (tmp[0] << 8);
        /* "a value of 0xffff means that the fan has stopped" */
        return (res == 0xffff ? 0 : (90000*60)/res);
}
 
static void write_both_fan_speed(struct thermostat *th, int speed)
{
        write_fan_speed(th, speed, 0);
        if (therm_type == ADT7460)
                write_fan_speed(th, speed, 1);
}
 
static void write_fan_speed(struct thermostat *th, int speed, int fan)
{
        u8 manual;
 
        if (speed > 0xff)
                speed = 0xff;
        else if (speed < -1)
                speed = 0;
 
        if (therm_type == ADT7467 && fan == 1)
                return;
 
        if (th->last_speed[fan] != speed) {
                if (verbose) {
                        if (speed == -1)
                                printk(KERN_DEBUG "adt746x: Setting speed to automatic "
                                        "for %s fan.\n", sensor_location[fan+1]);
                        else
                                printk(KERN_DEBUG "adt746x: Setting speed to %d "
                                        "for %s fan.\n", speed, sensor_location[fan+1]);
                }
        } else
                return;
 
        if (speed >= 0) {
                manual = read_reg(th, MANUAL_MODE[fan]);
                write_reg(th, MANUAL_MODE[fan], manual|MANUAL_MASK);
                write_reg(th, FAN_SPD_SET[fan], speed);
        } else {
                /* back to automatic */
                if(therm_type == ADT7460) {
                        manual = read_reg(th,
                                MANUAL_MODE[fan]) & (~MANUAL_MASK);
 
                        write_reg(th,
                                MANUAL_MODE[fan], manual|REM_CONTROL[fan]);
                } else {
                        manual = read_reg(th, MANUAL_MODE[fan]);
                        write_reg(th, MANUAL_MODE[fan], manual&(~AUTO_MASK));
                }
        }
 
        th->last_speed[fan] = speed;
}
 
static void read_sensors(struct thermostat *th)
{
        int i = 0;
 
        for (i = 0; i < 3; i++)
                th->temps[i]  = read_reg(th, TEMP_REG[i]);
}
 
#ifdef DEBUG
static void display_stats(struct thermostat *th)
{
        if (th->temps[0] != th->cached_temp[0]
        ||  th->temps[1] != th->cached_temp[1]
        ||  th->temps[2] != th->cached_temp[2]) {
                printk(KERN_INFO "adt746x: Temperature infos:"
                                 " thermostats: %d,%d,%d;"
                                 " limits: %d,%d,%d;"
                                 " fan speed: %d RPM\n",
                                 th->temps[0], th->temps[1], th->temps[2],
                                 th->limits[0],  th->limits[1],  th->limits[2],
                                 read_fan_speed(th, FAN_SPEED[0]));
        }
        th->cached_temp[0] = th->temps[0];
        th->cached_temp[1] = th->temps[1];
        th->cached_temp[2] = th->temps[2];
}
#endif
 
static void update_fans_speed (struct thermostat *th)
{
        int lastvar = 0; /* last variation, for iBook */
        int i = 0;
 
        /* we don't care about local sensor, so we start at sensor 1 */
        for (i = 1; i < 3; i++) {
                int started = 0;
                int fan_number = (therm_type == ADT7460 && i == 2);
                int var = th->temps[i] - th->limits[i];
 
                if (var > -1) {
                        int step = (255 - fan_speed) / 7;
                        int new_speed = 0;
 
                        /* hysteresis : change fan speed only if variation is
                         * more than two degrees */
                        if (abs(var - th->last_var[fan_number]) < 2)
                                continue;
 
                        started = 1;
                        new_speed = fan_speed + ((var-1)*step);
 
                        if (new_speed < fan_speed)
                                new_speed = fan_speed;
                        if (new_speed > 255)
                                new_speed = 255;
 
                        if (verbose)
                                printk(KERN_DEBUG "adt746x: Setting fans speed to %d "
                                                 "(limit exceeded by %d on %s) \n",
                                                new_speed, var,
                                                sensor_location[fan_number+1]);
                        write_both_fan_speed(th, new_speed);
                        th->last_var[fan_number] = var;
                } else if (var < -2) {
                        /* don't stop fan if sensor2 is cold and sensor1 is not
                         * so cold (lastvar >= -1) */
                        if (i == 2 && lastvar < -1) {
                                if (th->last_speed[fan_number] != 0)
                                        if (verbose)
                                                printk(KERN_DEBUG "adt746x: Stopping "
                                                        "fans.\n");
                                write_both_fan_speed(th, 0);
                        }
                }
 
                lastvar = var;
 
                if (started)
                        return; /* we don't want to re-stop the fan
                                * if sensor1 is heating and sensor2 is not */
        }
}
 
static int monitor_task(void *arg)
{
        struct thermostat* th = arg;
 
        set_freezable();
        while(!kthread_should_stop()) {
                try_to_freeze();
                msleep_interruptible(2000);
 
#ifndef DEBUG
                if (fan_speed != -1)
                        read_sensors(th);
#else
                read_sensors(th);
#endif          
 
                if (fan_speed != -1)
                        update_fans_speed(th);
 
#ifdef DEBUG
                display_stats(th);
#endif
 
        }
 
        return 0;
}
 
static void set_limit(struct thermostat *th, int i)
{
                /* Set sensor1 limit higher to avoid powerdowns */
                th->limits[i] = default_limits_chip[i] + limit_adjust;
                write_reg(th, LIMIT_REG[i], th->limits[i]);
 
                /* set our limits to normal */
                th->limits[i] = default_limits_local[i] + limit_adjust;
}
 
static int attach_one_thermostat(struct i2c_adapter *adapter, int addr,
                                 int busno)
{
        struct thermostat* th;
        int rc;
        int i;
 
        if (thermostat)
                return 0;
 
        th = kzalloc(sizeof(struct thermostat), GFP_KERNEL);
        if (!th)
                return -ENOMEM;
 
        th->clt.addr = addr;
        th->clt.adapter = adapter;
        th->clt.driver = &thermostat_driver;
        strcpy(th->clt.name, "thermostat");
 
        rc = read_reg(th, 0);
        if (rc < 0) {
                printk(KERN_ERR "adt746x: Thermostat failed to read config "
                                "from bus %d !\n",
                                busno);
                kfree(th);
                return -ENODEV;
        }
 
        /* force manual control to start the fan quieter */
        if (fan_speed == -1)
                fan_speed = 64;
 
        if(therm_type == ADT7460) {
                printk(KERN_INFO "adt746x: ADT7460 initializing\n");
                /* The 7460 needs to be started explicitly */
                write_reg(th, CONFIG_REG, 1);
        } else
                printk(KERN_INFO "adt746x: ADT7467 initializing\n");
 
        for (i = 0; i < 3; i++) {
                th->initial_limits[i] = read_reg(th, LIMIT_REG[i]);
                set_limit(th, i);
        }
 
        printk(KERN_INFO "adt746x: Lowering max temperatures from %d, %d, %d"
                         " to %d, %d, %d\n",
                         th->initial_limits[0], th->initial_limits[1],
                         th->initial_limits[2], th->limits[0], th->limits[1],
                         th->limits[2]);
 
        thermostat = th;
 
        if (i2c_attach_client(&th->clt)) {
                printk(KERN_INFO "adt746x: Thermostat failed to attach "
                                 "client !\n");
                thermostat = NULL;
                kfree(th);
                return -ENODEV;
        }
 
        /* be sure to really write fan speed the first time */
        th->last_speed[0] = -2;
        th->last_speed[1] = -2;
        th->last_var[0] = -80;
        th->last_var[1] = -80;
 
        if (fan_speed != -1) {
                /* manual mode, stop fans */
                write_both_fan_speed(th, 0);
        } else {
                /* automatic mode */
                write_both_fan_speed(th, -1);
        }
 
        thread_therm = kthread_run(monitor_task, th, "kfand");
 
        if (thread_therm == ERR_PTR(-ENOMEM)) {
                printk(KERN_INFO "adt746x: Kthread creation failed\n");
                thread_therm = NULL;
                return -ENOMEM;
        }
 
        return 0;
}
 
/*
 * Now, unfortunately, sysfs doesn't give us a nice void * we could
 * pass around to the attribute functions, so we don't really have
 * choice but implement a bunch of them...
 *
 * FIXME, it does now...
 */
#define BUILD_SHOW_FUNC_INT(name, data)                         \
static ssize_t show_##name(struct device *dev, struct device_attribute *attr, char *buf)        \
{                                                               \
        return sprintf(buf, "%d\n", data);                      \
}
 
#define BUILD_SHOW_FUNC_STR(name, data)                         \
static ssize_t show_##name(struct device *dev, struct device_attribute *attr, char *buf)       \
{                                                               \
        return sprintf(buf, "%s\n", data);                      \
}
 
#define BUILD_SHOW_FUNC_FAN(name, data)                         \
static ssize_t show_##name(struct device *dev, struct device_attribute *attr, char *buf)       \
{                                                               \
        return sprintf(buf, "%d (%d rpm)\n",                    \
                thermostat->last_speed[data],                   \
                read_fan_speed(thermostat, FAN_SPEED[data])     \
                );                                              \
}
 
#define BUILD_STORE_FUNC_DEG(name, data)                        \
static ssize_t store_##name(struct device *dev, struct device_attribute *attr, const char *buf, size_t n) \
{                                                               \
        int val;                                                \
        int i;                                                  \
        val = simple_strtol(buf, NULL, 10);                     \
        printk(KERN_INFO "Adjusting limits by %d degrees\n", val);      \
        limit_adjust = val;                                     \
        for (i=0; i < 3; i++)                                    \
                set_limit(thermostat, i);                       \
        return n;                                               \
}
 
#define BUILD_STORE_FUNC_INT(name, data)                        \
static ssize_t store_##name(struct device *dev, struct device_attribute *attr, const char *buf, size_t n) \
{                                                               \
        u32 val;                                                \
        val = simple_strtoul(buf, NULL, 10);                    \
        if (val < 0 || val > 255)                                \
                return -EINVAL;                                 \
        printk(KERN_INFO "Setting specified fan speed to %d\n", val);   \
        data = val;                                             \
        return n;                                               \
}
 
BUILD_SHOW_FUNC_INT(sensor1_temperature,         (read_reg(thermostat, TEMP_REG[1])))
BUILD_SHOW_FUNC_INT(sensor2_temperature,         (read_reg(thermostat, TEMP_REG[2])))
BUILD_SHOW_FUNC_INT(sensor1_limit,               thermostat->limits[1])
BUILD_SHOW_FUNC_INT(sensor2_limit,               thermostat->limits[2])
BUILD_SHOW_FUNC_STR(sensor1_location,            sensor_location[1])
BUILD_SHOW_FUNC_STR(sensor2_location,            sensor_location[2])
 
BUILD_SHOW_FUNC_INT(specified_fan_speed, fan_speed)
BUILD_SHOW_FUNC_FAN(sensor1_fan_speed,   0)
BUILD_SHOW_FUNC_FAN(sensor2_fan_speed,   1)
 
BUILD_STORE_FUNC_INT(specified_fan_speed,fan_speed)
BUILD_SHOW_FUNC_INT(limit_adjust,        limit_adjust)
BUILD_STORE_FUNC_DEG(limit_adjust,       thermostat)
 
static DEVICE_ATTR(sensor1_temperature, S_IRUGO,
                   show_sensor1_temperature,NULL);
static DEVICE_ATTR(sensor2_temperature, S_IRUGO,
                   show_sensor2_temperature,NULL);
static DEVICE_ATTR(sensor1_limit, S_IRUGO,
                   show_sensor1_limit,  NULL);
static DEVICE_ATTR(sensor2_limit, S_IRUGO,
                   show_sensor2_limit,  NULL);
static DEVICE_ATTR(sensor1_location, S_IRUGO,
                   show_sensor1_location, NULL);
static DEVICE_ATTR(sensor2_location, S_IRUGO,
                   show_sensor2_location, NULL);
 
static DEVICE_ATTR(specified_fan_speed, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH,
                   show_specified_fan_speed,store_specified_fan_speed);
 
static DEVICE_ATTR(sensor1_fan_speed,   S_IRUGO,
                   show_sensor1_fan_speed,      NULL);
static DEVICE_ATTR(sensor2_fan_speed,   S_IRUGO,
                   show_sensor2_fan_speed,      NULL);
 
static DEVICE_ATTR(limit_adjust,        S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH,
                   show_limit_adjust,   store_limit_adjust);
 
 
static int __init
thermostat_init(void)
{
        struct device_node* np;
        const u32 *prop;
        int i = 0, offset = 0;
 
        np = of_find_node_by_name(NULL, "fan");
        if (!np)
                return -ENODEV;
        if (of_device_is_compatible(np, "adt7460"))
                therm_type = ADT7460;
        else if (of_device_is_compatible(np, "adt7467"))
                therm_type = ADT7467;
        else
                return -ENODEV;
 
        prop = of_get_property(np, "hwsensor-params-version", NULL);
        printk(KERN_INFO "adt746x: version %d (%ssupported)\n", *prop,
                         (*prop == 1)?"":"un");
        if (*prop != 1)
                return -ENODEV;
 
        prop = of_get_property(np, "reg", NULL);
        if (!prop)
                return -ENODEV;
 
        /* look for bus either by path or using "reg" */
        if (strstr(np->full_name, "/i2c-bus@") != NULL) {
                const char *tmp_bus = (strstr(np->full_name, "/i2c-bus@") + 9);
                therm_bus = tmp_bus[0]-'0';
        } else {
                therm_bus = ((*prop) >> 8) & 0x0f;
        }
 
        therm_address = ((*prop) & 0xff) >> 1;
 
        printk(KERN_INFO "adt746x: Thermostat bus: %d, address: 0x%02x, "
                         "limit_adjust: %d, fan_speed: %d\n",
                         therm_bus, therm_address, limit_adjust, fan_speed);
 
        if (of_get_property(np, "hwsensor-location", NULL)) {
                for (i = 0; i < 3; i++) {
                        sensor_location[i] = of_get_property(np,
                                        "hwsensor-location", NULL) + offset;
 
                        if (sensor_location[i] == NULL)
                                sensor_location[i] = "";
 
                        printk(KERN_INFO "sensor %d: %s\n", i, sensor_location[i]);
                        offset += strlen(sensor_location[i]) + 1;
                }
        } else {
                sensor_location[0] = "?";
                sensor_location[1] = "?";
                sensor_location[2] = "?";
        }
 
        of_dev = of_platform_device_create(np, "temperatures", NULL);
 
        if (of_dev == NULL) {
                printk(KERN_ERR "Can't register temperatures device !\n");
                return -ENODEV;
        }
 
        device_create_file(&of_dev->dev, &dev_attr_sensor1_temperature);
        device_create_file(&of_dev->dev, &dev_attr_sensor2_temperature);
        device_create_file(&of_dev->dev, &dev_attr_sensor1_limit);
        device_create_file(&of_dev->dev, &dev_attr_sensor2_limit);
        device_create_file(&of_dev->dev, &dev_attr_sensor1_location);
        device_create_file(&of_dev->dev, &dev_attr_sensor2_location);
        device_create_file(&of_dev->dev, &dev_attr_limit_adjust);
        device_create_file(&of_dev->dev, &dev_attr_specified_fan_speed);
        device_create_file(&of_dev->dev, &dev_attr_sensor1_fan_speed);
        if(therm_type == ADT7460)
                device_create_file(&of_dev->dev, &dev_attr_sensor2_fan_speed);
 
#ifndef CONFIG_I2C_POWERMAC
        request_module("i2c-powermac");
#endif
 
        return i2c_add_driver(&thermostat_driver);
}
 
static void __exit
thermostat_exit(void)
{
        if (of_dev) {
                device_remove_file(&of_dev->dev, &dev_attr_sensor1_temperature);
                device_remove_file(&of_dev->dev, &dev_attr_sensor2_temperature);
                device_remove_file(&of_dev->dev, &dev_attr_sensor1_limit);
                device_remove_file(&of_dev->dev, &dev_attr_sensor2_limit);
                device_remove_file(&of_dev->dev, &dev_attr_sensor1_location);
                device_remove_file(&of_dev->dev, &dev_attr_sensor2_location);
                device_remove_file(&of_dev->dev, &dev_attr_limit_adjust);
                device_remove_file(&of_dev->dev, &dev_attr_specified_fan_speed);
                device_remove_file(&of_dev->dev, &dev_attr_sensor1_fan_speed);
 
                if(therm_type == ADT7460)
                        device_remove_file(&of_dev->dev,
                                           &dev_attr_sensor2_fan_speed);
 
                of_device_unregister(of_dev);
        }
        i2c_del_driver(&thermostat_driver);
}
 
module_init(thermostat_init);
module_exit(thermostat_exit);

Browse

Tools

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [macintosh/] [therm_adt746x.c] - Blame information for rev 62

Line No.	Rev	Author	Line
1	62	marcus.erl	`/*`
2			`* Device driver for the i2c thermostat found on the iBook G4, Albook G4`
3			`*`
4			`* Copyright (C) 2003, 2004 Colin Leroy, Rasmus Rohde, Benjamin Herrenschmidt`
5			`*`
6			`* Documentation from`
7			`* http://www.analog.com/UploadedFiles/Data_Sheets/115254175ADT7467_pra.pdf`
8			`* http://www.analog.com/UploadedFiles/Data_Sheets/3686221171167ADT7460_b.pdf`
9			`*`
10			`*/`
11
12			`#include <linux/types.h>`
13			`#include <linux/module.h>`
14			`#include <linux/errno.h>`
15			`#include <linux/kernel.h>`
16			`#include <linux/delay.h>`
17			`#include <linux/sched.h>`
18			`#include <linux/i2c.h>`
19			`#include <linux/slab.h>`
20			`#include <linux/init.h>`
21			`#include <linux/spinlock.h>`
22			`#include <linux/wait.h>`
23			`#include <linux/suspend.h>`
24			`#include <linux/kthread.h>`
25			`#include <linux/moduleparam.h>`
26			`#include <linux/freezer.h>`
27
28			`#include <asm/prom.h>`
29			`#include <asm/machdep.h>`
30			`#include <asm/io.h>`
31			`#include <asm/system.h>`
32			`#include <asm/sections.h>`
33			`#include <asm/of_platform.h>`
34
35			`#undef DEBUG`
36
37			`#define CONFIG_REG 0x40`
38			`#define MANUAL_MASK 0xe0`
39			`#define AUTO_MASK 0x20`
40
41			`static u8 TEMP_REG[3] = {0x26, 0x25, 0x27}; /* local, sensor1, sensor2 */`
42			`static u8 LIMIT_REG[3] = {0x6b, 0x6a, 0x6c}; /* local, sensor1, sensor2 */`
43			`static u8 MANUAL_MODE[2] = {0x5c, 0x5d};`
44			`static u8 REM_CONTROL[2] = {0x00, 0x40};`
45			`static u8 FAN_SPEED[2] = {0x28, 0x2a};`
46			`static u8 FAN_SPD_SET[2] = {0x30, 0x31};`
47
48			`static u8 default_limits_local[3] = {70, 50, 70}; /* local, sensor1, sensor2 */`
49			`static u8 default_limits_chip[3] = {80, 65, 80}; /* local, sensor1, sensor2 */`
50			`static const char *sensor_location[3];`
51
52			`static int limit_adjust;`
53			`static int fan_speed = -1;`
54			`static int verbose;`
55
56			`MODULE_AUTHOR("Colin Leroy <colin@colino.net>");`
57			`MODULE_DESCRIPTION("Driver for ADT746x thermostat in iBook G4 and "`
58			`"Powerbook G4 Alu");`
59			`MODULE_LICENSE("GPL");`
60
61			`module_param(limit_adjust, int, 0644);`
62			`MODULE_PARM_DESC(limit_adjust,"Adjust maximum temperatures (50 sensor1, 70 sensor2) "`
63			`"by N degrees.");`
64
65			`module_param(fan_speed, int, 0644);`
66			`MODULE_PARM_DESC(fan_speed,"Specify starting fan speed (0-255) "`
67			`"(default 64)");`
68
69			`module_param(verbose, bool, 0);`
70			`MODULE_PARM_DESC(verbose,"Verbose log operations "`
71			`"(default 0)");`
72
73			`struct thermostat {`
74			`struct i2c_client clt;`
75			`u8 temps[3];`
76			`u8 cached_temp[3];`
77			`u8 initial_limits[3];`
78			`u8 limits[3];`
79			`int last_speed[2];`
80			`int last_var[2];`
81			`};`
82
83			`static enum {ADT7460, ADT7467} therm_type;`
84			`static int therm_bus, therm_address;`
85			`static struct of_device * of_dev;`
86			`static struct thermostat* thermostat;`
87			`static struct task_struct *thread_therm = NULL;`
88
89			`static int attach_one_thermostat(struct i2c_adapter *adapter, int addr,`
90			`int busno);`
91
92			`static void write_both_fan_speed(struct thermostat *th, int speed);`
93			`static void write_fan_speed(struct thermostat *th, int speed, int fan);`
94
95			`static int`
96			`write_reg(struct thermostat* th, int reg, u8 data)`
97			`{`
98			`u8 tmp[2];`
99			`int rc;`
100
101			`tmp[0] = reg;`
102			`tmp[1] = data;`
103			`rc = i2c_master_send(&th->clt, (const char *)tmp, 2);`
104			`if (rc < 0)`
105			`return rc;`
106			`if (rc != 2)`
107			`return -ENODEV;`
108			`return 0;`
109			`}`
110
111			`static int`
112			`read_reg(struct thermostat* th, int reg)`
113			`{`
114			`u8 reg_addr, data;`
115			`int rc;`
116
117			`reg_addr = (u8)reg;`
118			`rc = i2c_master_send(&th->clt, &reg_addr, 1);`
119			`if (rc < 0)`
120			`return rc;`
121			`if (rc != 1)`
122			`return -ENODEV;`
123			`rc = i2c_master_recv(&th->clt, (char *)&data, 1);`
124			`if (rc < 0)`
125			`return rc;`
126			`return data;`
127			`}`
128
129			`static int`
130			`attach_thermostat(struct i2c_adapter *adapter)`
131			`{`
132			`unsigned long bus_no;`
133
134			`if (strncmp(adapter->name, "uni-n", 5))`
135			`return -ENODEV;`
136			`bus_no = simple_strtoul(adapter->name + 6, NULL, 10);`
137			`if (bus_no != therm_bus)`
138			`return -ENODEV;`
139			`return attach_one_thermostat(adapter, therm_address, bus_no);`
140			`}`
141
142			`static int`
143			`detach_thermostat(struct i2c_adapter *adapter)`
144			`{`
145			`struct thermostat* th;`
146			`int i;`
147
148			`if (thermostat == NULL)`
149			`return 0;`
150
151			`th = thermostat;`
152
153			`if (thread_therm != NULL) {`
154			`kthread_stop(thread_therm);`
155			`}`
156
157			`printk(KERN_INFO "adt746x: Putting max temperatures back from "`
158			`"%d, %d, %d to %d, %d, %d\n",`
159			`th->limits[0], th->limits[1], th->limits[2],`
160			`th->initial_limits[0], th->initial_limits[1],`
161			`th->initial_limits[2]);`
162
163			`for (i = 0; i < 3; i++)`
164			`write_reg(th, LIMIT_REG[i], th->initial_limits[i]);`
165
166			`write_both_fan_speed(th, -1);`
167
168			`i2c_detach_client(&th->clt);`
169
170			`thermostat = NULL;`
171
172			`kfree(th);`
173
174			`return 0;`
175			`}`
176
177			`static struct i2c_driver thermostat_driver = {`
178			`.driver = {`
179			`.name = "therm_adt746x",`
180			`},`
181			`.attach_adapter = attach_thermostat,`
182			`.detach_adapter = detach_thermostat,`
183			`};`
184
185			`static int read_fan_speed(struct thermostat *th, u8 addr)`
186			`{`
187			`u8 tmp[2];`
188			`u16 res;`
189
190			`/* should start with low byte */`
191			`tmp[1] = read_reg(th, addr);`
192			`tmp[0] = read_reg(th, addr + 1);`
193
194			`res = tmp[1] + (tmp[0] << 8);`
195			`/* "a value of 0xffff means that the fan has stopped" */`
196			`return (res == 0xffff ? 0 : (90000*60)/res);`
197			`}`
198
199			`static void write_both_fan_speed(struct thermostat *th, int speed)`
200			`{`
201			`write_fan_speed(th, speed, 0);`
202			`if (therm_type == ADT7460)`
203			`write_fan_speed(th, speed, 1);`
204			`}`
205
206			`static void write_fan_speed(struct thermostat *th, int speed, int fan)`
207			`{`
208			`u8 manual;`
209
210			`if (speed > 0xff)`
211			`speed = 0xff;`
212			`else if (speed < -1)`
213			`speed = 0;`
214
215			`if (therm_type == ADT7467 && fan == 1)`
216			`return;`
217
218			`if (th->last_speed[fan] != speed) {`
219			`if (verbose) {`
220			`if (speed == -1)`
221			`printk(KERN_DEBUG "adt746x: Setting speed to automatic "`
222			`"for %s fan.\n", sensor_location[fan+1]);`
223			`else`
224			`printk(KERN_DEBUG "adt746x: Setting speed to %d "`
225			`"for %s fan.\n", speed, sensor_location[fan+1]);`
226			`}`
227			`} else`
228			`return;`
229
230			`if (speed >= 0) {`
231			`manual = read_reg(th, MANUAL_MODE[fan]);`
232			`write_reg(th, MANUAL_MODE[fan], manual\|MANUAL_MASK);`
233			`write_reg(th, FAN_SPD_SET[fan], speed);`
234			`} else {`
235			`/* back to automatic */`
236			`if(therm_type == ADT7460) {`
237			`manual = read_reg(th,`
238			`MANUAL_MODE[fan]) & (~MANUAL_MASK);`
239
240			`write_reg(th,`
241			`MANUAL_MODE[fan], manual\|REM_CONTROL[fan]);`
242			`} else {`
243			`manual = read_reg(th, MANUAL_MODE[fan]);`
244			`write_reg(th, MANUAL_MODE[fan], manual&(~AUTO_MASK));`
245			`}`
246			`}`
247
248			`th->last_speed[fan] = speed;`
249			`}`
250
251			`static void read_sensors(struct thermostat *th)`
252			`{`
253			`int i = 0;`
254
255			`for (i = 0; i < 3; i++)`
256			`th->temps[i] = read_reg(th, TEMP_REG[i]);`
257			`}`
258
259			`#ifdef DEBUG`
260			`static void display_stats(struct thermostat *th)`
261			`{`
262			`if (th->temps[0] != th->cached_temp[0]`
263			`\|\| th->temps[1] != th->cached_temp[1]`
264			`\|\| th->temps[2] != th->cached_temp[2]) {`
265			`printk(KERN_INFO "adt746x: Temperature infos:"`
266			`" thermostats: %d,%d,%d;"`
267			`" limits: %d,%d,%d;"`
268			`" fan speed: %d RPM\n",`
269			`th->temps[0], th->temps[1], th->temps[2],`
270			`th->limits[0], th->limits[1], th->limits[2],`
271			`read_fan_speed(th, FAN_SPEED[0]));`
272			`}`
273			`th->cached_temp[0] = th->temps[0];`
274			`th->cached_temp[1] = th->temps[1];`
275			`th->cached_temp[2] = th->temps[2];`
276			`}`
277			`#endif`
278
279			`static void update_fans_speed (struct thermostat *th)`
280			`{`
281			`int lastvar = 0; /* last variation, for iBook */`
282			`int i = 0;`
283
284			`/* we don't care about local sensor, so we start at sensor 1 */`
285			`for (i = 1; i < 3; i++) {`
286			`int started = 0;`
287			`int fan_number = (therm_type == ADT7460 && i == 2);`
288			`int var = th->temps[i] - th->limits[i];`
289
290			`if (var > -1) {`
291			`int step = (255 - fan_speed) / 7;`
292			`int new_speed = 0;`
293
294			`/* hysteresis : change fan speed only if variation is`
295			`* more than two degrees */`
296			`if (abs(var - th->last_var[fan_number]) < 2)`
297			`continue;`
298
299			`started = 1;`
300			`new_speed = fan_speed + ((var-1)*step);`
301
302			`if (new_speed < fan_speed)`
303			`new_speed = fan_speed;`
304			`if (new_speed > 255)`
305			`new_speed = 255;`
306
307			`if (verbose)`
308			`printk(KERN_DEBUG "adt746x: Setting fans speed to %d "`
309			`"(limit exceeded by %d on %s) \n",`
310			`new_speed, var,`
311			`sensor_location[fan_number+1]);`
312			`write_both_fan_speed(th, new_speed);`
313			`th->last_var[fan_number] = var;`
314			`} else if (var < -2) {`
315			`/* don't stop fan if sensor2 is cold and sensor1 is not`
316			`* so cold (lastvar >= -1) */`
317			`if (i == 2 && lastvar < -1) {`
318			`if (th->last_speed[fan_number] != 0)`
319			`if (verbose)`
320			`printk(KERN_DEBUG "adt746x: Stopping "`
321			`"fans.\n");`
322			`write_both_fan_speed(th, 0);`
323			`}`
324			`}`
325
326			`lastvar = var;`
327
328			`if (started)`
329			`return; /* we don't want to re-stop the fan`
330			`* if sensor1 is heating and sensor2 is not */`
331			`}`
332			`}`
333
334			`static int monitor_task(void *arg)`
335			`{`
336			`struct thermostat* th = arg;`
337
338			`set_freezable();`
339			`while(!kthread_should_stop()) {`
340			`try_to_freeze();`
341			`msleep_interruptible(2000);`
342
343			`#ifndef DEBUG`
344			`if (fan_speed != -1)`
345			`read_sensors(th);`
346			`#else`
347			`read_sensors(th);`
348			`#endif`
349
350			`if (fan_speed != -1)`
351			`update_fans_speed(th);`
352
353			`#ifdef DEBUG`
354			`display_stats(th);`
355			`#endif`
356
357			`}`
358
359			`return 0;`
360			`}`
361
362			`static void set_limit(struct thermostat *th, int i)`
363			`{`
364			`/* Set sensor1 limit higher to avoid powerdowns */`
365			`th->limits[i] = default_limits_chip[i] + limit_adjust;`
366			`write_reg(th, LIMIT_REG[i], th->limits[i]);`
367
368			`/* set our limits to normal */`
369			`th->limits[i] = default_limits_local[i] + limit_adjust;`
370			`}`
371
372			`static int attach_one_thermostat(struct i2c_adapter *adapter, int addr,`
373			`int busno)`
374			`{`
375			`struct thermostat* th;`
376			`int rc;`
377			`int i;`
378
379			`if (thermostat)`
380			`return 0;`
381
382			`th = kzalloc(sizeof(struct thermostat), GFP_KERNEL);`
383			`if (!th)`
384			`return -ENOMEM;`
385
386			`th->clt.addr = addr;`
387			`th->clt.adapter = adapter;`
388			`th->clt.driver = &thermostat_driver;`
389			`strcpy(th->clt.name, "thermostat");`
390
391			`rc = read_reg(th, 0);`
392			`if (rc < 0) {`
393			`printk(KERN_ERR "adt746x: Thermostat failed to read config "`
394			`"from bus %d !\n",`
395			`busno);`
396			`kfree(th);`
397			`return -ENODEV;`
398			`}`
399
400			`/* force manual control to start the fan quieter */`
401			`if (fan_speed == -1)`
402			`fan_speed = 64;`
403
404			`if(therm_type == ADT7460) {`
405			`printk(KERN_INFO "adt746x: ADT7460 initializing\n");`
406			`/* The 7460 needs to be started explicitly */`
407			`write_reg(th, CONFIG_REG, 1);`
408			`} else`
409			`printk(KERN_INFO "adt746x: ADT7467 initializing\n");`
410
411			`for (i = 0; i < 3; i++) {`
412			`th->initial_limits[i] = read_reg(th, LIMIT_REG[i]);`
413			`set_limit(th, i);`
414			`}`
415
416			`printk(KERN_INFO "adt746x: Lowering max temperatures from %d, %d, %d"`
417			`" to %d, %d, %d\n",`
418			`th->initial_limits[0], th->initial_limits[1],`
419			`th->initial_limits[2], th->limits[0], th->limits[1],`
420			`th->limits[2]);`
421
422			`thermostat = th;`
423
424			`if (i2c_attach_client(&th->clt)) {`
425			`printk(KERN_INFO "adt746x: Thermostat failed to attach "`
426			`"client !\n");`
427			`thermostat = NULL;`
428			`kfree(th);`
429			`return -ENODEV;`
430			`}`
431
432			`/* be sure to really write fan speed the first time */`
433			`th->last_speed[0] = -2;`
434			`th->last_speed[1] = -2;`
435			`th->last_var[0] = -80;`
436			`th->last_var[1] = -80;`
437
438			`if (fan_speed != -1) {`
439			`/* manual mode, stop fans */`
440			`write_both_fan_speed(th, 0);`
441			`} else {`
442			`/* automatic mode */`
443			`write_both_fan_speed(th, -1);`
444			`}`
445
446			`thread_therm = kthread_run(monitor_task, th, "kfand");`
447
448			`if (thread_therm == ERR_PTR(-ENOMEM)) {`
449			`printk(KERN_INFO "adt746x: Kthread creation failed\n");`
450			`thread_therm = NULL;`
451			`return -ENOMEM;`
452			`}`
453
454			`return 0;`
455			`}`
456
457			`/*`
458			`* Now, unfortunately, sysfs doesn't give us a nice void * we could`
459			`* pass around to the attribute functions, so we don't really have`
460			`* choice but implement a bunch of them...`
461			`*`
462			`* FIXME, it does now...`
463			`*/`
464			`#define BUILD_SHOW_FUNC_INT(name, data) \`
465			`static ssize_t show_##name(struct device dev, struct device_attribute attr, char *buf) \`
466			`{ \`
467			`return sprintf(buf, "%d\n", data); \`
468			`}`
469
470			`#define BUILD_SHOW_FUNC_STR(name, data) \`
471			`static ssize_t show_##name(struct device dev, struct device_attribute attr, char *buf) \`
472			`{ \`
473			`return sprintf(buf, "%s\n", data); \`
474			`}`
475
476			`#define BUILD_SHOW_FUNC_FAN(name, data) \`
477			`static ssize_t show_##name(struct device dev, struct device_attribute attr, char *buf) \`
478			`{ \`
479			`return sprintf(buf, "%d (%d rpm)\n", \`
480			`thermostat->last_speed[data], \`
481			`read_fan_speed(thermostat, FAN_SPEED[data]) \`
482			`); \`
483			`}`
484
485			`#define BUILD_STORE_FUNC_DEG(name, data) \`
486			`static ssize_t store_##name(struct device dev, struct device_attribute attr, const char *buf, size_t n) \`
487			`{ \`
488			`int val; \`
489			`int i; \`
490			`val = simple_strtol(buf, NULL, 10); \`
491			`printk(KERN_INFO "Adjusting limits by %d degrees\n", val); \`
492			`limit_adjust = val; \`
493			`for (i=0; i < 3; i++) \`
494			`set_limit(thermostat, i); \`
495			`return n; \`
496			`}`
497
498			`#define BUILD_STORE_FUNC_INT(name, data) \`
499			`static ssize_t store_##name(struct device dev, struct device_attribute attr, const char *buf, size_t n) \`
500			`{ \`
501			`u32 val; \`
502			`val = simple_strtoul(buf, NULL, 10); \`
503			`if (val < 0 \|\| val > 255) \`
504			`return -EINVAL; \`
505			`printk(KERN_INFO "Setting specified fan speed to %d\n", val); \`
506			`data = val; \`
507			`return n; \`
508			`}`
509
510			`BUILD_SHOW_FUNC_INT(sensor1_temperature, (read_reg(thermostat, TEMP_REG[1])))`
511			`BUILD_SHOW_FUNC_INT(sensor2_temperature, (read_reg(thermostat, TEMP_REG[2])))`
512			`BUILD_SHOW_FUNC_INT(sensor1_limit, thermostat->limits[1])`
513			`BUILD_SHOW_FUNC_INT(sensor2_limit, thermostat->limits[2])`
514			`BUILD_SHOW_FUNC_STR(sensor1_location, sensor_location[1])`
515			`BUILD_SHOW_FUNC_STR(sensor2_location, sensor_location[2])`
516
517			`BUILD_SHOW_FUNC_INT(specified_fan_speed, fan_speed)`
518			`BUILD_SHOW_FUNC_FAN(sensor1_fan_speed, 0)`
519			`BUILD_SHOW_FUNC_FAN(sensor2_fan_speed, 1)`
520
521			`BUILD_STORE_FUNC_INT(specified_fan_speed,fan_speed)`
522			`BUILD_SHOW_FUNC_INT(limit_adjust, limit_adjust)`
523			`BUILD_STORE_FUNC_DEG(limit_adjust, thermostat)`
524
525			`static DEVICE_ATTR(sensor1_temperature, S_IRUGO,`
526			`show_sensor1_temperature,NULL);`
527			`static DEVICE_ATTR(sensor2_temperature, S_IRUGO,`
528			`show_sensor2_temperature,NULL);`
529			`static DEVICE_ATTR(sensor1_limit, S_IRUGO,`
530			`show_sensor1_limit, NULL);`
531			`static DEVICE_ATTR(sensor2_limit, S_IRUGO,`
532			`show_sensor2_limit, NULL);`
533			`static DEVICE_ATTR(sensor1_location, S_IRUGO,`
534			`show_sensor1_location, NULL);`
535			`static DEVICE_ATTR(sensor2_location, S_IRUGO,`
536			`show_sensor2_location, NULL);`
537
538			`static DEVICE_ATTR(specified_fan_speed, S_IRUSR\|S_IWUSR\|S_IRGRP\|S_IROTH,`
539			`show_specified_fan_speed,store_specified_fan_speed);`
540
541			`static DEVICE_ATTR(sensor1_fan_speed, S_IRUGO,`
542			`show_sensor1_fan_speed, NULL);`
543			`static DEVICE_ATTR(sensor2_fan_speed, S_IRUGO,`
544			`show_sensor2_fan_speed, NULL);`
545
546			`static DEVICE_ATTR(limit_adjust, S_IRUSR\|S_IWUSR\|S_IRGRP\|S_IROTH,`
547			`show_limit_adjust, store_limit_adjust);`
548
549
550			`static int __init`
551			`thermostat_init(void)`
552			`{`
553			`struct device_node* np;`
554			`const u32 *prop;`
555			`int i = 0, offset = 0;`
556
557			`np = of_find_node_by_name(NULL, "fan");`
558			`if (!np)`
559			`return -ENODEV;`
560			`if (of_device_is_compatible(np, "adt7460"))`
561			`therm_type = ADT7460;`
562			`else if (of_device_is_compatible(np, "adt7467"))`
563			`therm_type = ADT7467;`
564			`else`
565			`return -ENODEV;`
566
567			`prop = of_get_property(np, "hwsensor-params-version", NULL);`
568			`printk(KERN_INFO "adt746x: version %d (%ssupported)\n", *prop,`
569			`(*prop == 1)?"":"un");`
570			`if (*prop != 1)`
571			`return -ENODEV;`
572
573			`prop = of_get_property(np, "reg", NULL);`
574			`if (!prop)`
575			`return -ENODEV;`
576
577			`/* look for bus either by path or using "reg" */`
578			`if (strstr(np->full_name, "/i2c-bus@") != NULL) {`
579			`const char *tmp_bus = (strstr(np->full_name, "/i2c-bus@") + 9);`
580			`therm_bus = tmp_bus[0]-'0';`
581			`} else {`
582			`therm_bus = ((*prop) >> 8) & 0x0f;`
583			`}`
584
585			`therm_address = ((*prop) & 0xff) >> 1;`
586
587			`printk(KERN_INFO "adt746x: Thermostat bus: %d, address: 0x%02x, "`
588			`"limit_adjust: %d, fan_speed: %d\n",`
589			`therm_bus, therm_address, limit_adjust, fan_speed);`
590
591			`if (of_get_property(np, "hwsensor-location", NULL)) {`
592			`for (i = 0; i < 3; i++) {`
593			`sensor_location[i] = of_get_property(np,`
594			`"hwsensor-location", NULL) + offset;`
595
596			`if (sensor_location[i] == NULL)`
597			`sensor_location[i] = "";`
598
599			`printk(KERN_INFO "sensor %d: %s\n", i, sensor_location[i]);`
600			`offset += strlen(sensor_location[i]) + 1;`
601			`}`
602			`} else {`
603			`sensor_location[0] = "?";`
604			`sensor_location[1] = "?";`
605			`sensor_location[2] = "?";`
606			`}`
607
608			`of_dev = of_platform_device_create(np, "temperatures", NULL);`
609
610			`if (of_dev == NULL) {`
611			`printk(KERN_ERR "Can't register temperatures device !\n");`
612			`return -ENODEV;`
613			`}`
614
615			`device_create_file(&of_dev->dev, &dev_attr_sensor1_temperature);`
616			`device_create_file(&of_dev->dev, &dev_attr_sensor2_temperature);`
617			`device_create_file(&of_dev->dev, &dev_attr_sensor1_limit);`
618			`device_create_file(&of_dev->dev, &dev_attr_sensor2_limit);`
619			`device_create_file(&of_dev->dev, &dev_attr_sensor1_location);`
620			`device_create_file(&of_dev->dev, &dev_attr_sensor2_location);`
621			`device_create_file(&of_dev->dev, &dev_attr_limit_adjust);`
622			`device_create_file(&of_dev->dev, &dev_attr_specified_fan_speed);`
623			`device_create_file(&of_dev->dev, &dev_attr_sensor1_fan_speed);`
624			`if(therm_type == ADT7460)`
625			`device_create_file(&of_dev->dev, &dev_attr_sensor2_fan_speed);`
626
627			`#ifndef CONFIG_I2C_POWERMAC`
628			`request_module("i2c-powermac");`
629			`#endif`
630
631			`return i2c_add_driver(&thermostat_driver);`
632			`}`
633
634			`static void __exit`
635			`thermostat_exit(void)`
636			`{`
637			`if (of_dev) {`
638			`device_remove_file(&of_dev->dev, &dev_attr_sensor1_temperature);`
639			`device_remove_file(&of_dev->dev, &dev_attr_sensor2_temperature);`
640			`device_remove_file(&of_dev->dev, &dev_attr_sensor1_limit);`
641			`device_remove_file(&of_dev->dev, &dev_attr_sensor2_limit);`
642			`device_remove_file(&of_dev->dev, &dev_attr_sensor1_location);`
643			`device_remove_file(&of_dev->dev, &dev_attr_sensor2_location);`
644			`device_remove_file(&of_dev->dev, &dev_attr_limit_adjust);`
645			`device_remove_file(&of_dev->dev, &dev_attr_specified_fan_speed);`
646			`device_remove_file(&of_dev->dev, &dev_attr_sensor1_fan_speed);`
647
648			`if(therm_type == ADT7460)`
649			`device_remove_file(&of_dev->dev,`
650			`&dev_attr_sensor2_fan_speed);`
651
652			`of_device_unregister(of_dev);`
653			`}`
654			`i2c_del_driver(&thermostat_driver);`
655			`}`
656
657			`module_init(thermostat_init);`
658			`module_exit(thermostat_exit);`