Subversion Repositories or1k

/*

 * Copyright (C) 2001,2002,2003 Broadcom Corporation

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

 */

/*

 * SMBus/I2C device driver for the MAX1617 temperature sensor

 */

#include <linux/config.h>

#include <linux/kernel.h>

#include <linux/module.h>

#include <linux/slab.h>

#include <linux/timer.h>

#include <linux/errno.h>

#include <linux/i2c.h>

#include <linux/i2c-algo-sibyte.h>

#define IF_NAME "max1617"

#define MAX1617_SMBUS_DEV       0x2A

#define MAX1617_LOCAL           0

#define MAX1617_REMOTE          1

#define MAX1617_STATUS          2

#define MAX1617_POLL_PERIOD    10

static int max1617_verbose = 0;

static int max1617_polling = 1;

/* Addresses to scan */

static unsigned short normal_i2c[] = {MAX1617_SMBUS_DEV, I2C_CLIENT_END};

static unsigned short normal_i2c_range[] = {I2C_CLIENT_END};

static unsigned short probe[2]        = { I2C_CLIENT_END, I2C_CLIENT_END };

static unsigned short probe_range[2]  = { I2C_CLIENT_END, I2C_CLIENT_END };

static unsigned short ignore[2]       = { I2C_CLIENT_END, I2C_CLIENT_END };

static unsigned short ignore_range[2] = { I2C_CLIENT_END, I2C_CLIENT_END };

static unsigned short force[2]        = { I2C_CLIENT_END, I2C_CLIENT_END };

static struct i2c_client_address_data addr_data = {

        normal_i2c, normal_i2c_range,

        probe, probe_range,

        ignore, ignore_range,

        force

};

struct max1617_info {

        struct i2c_client *client;

        struct timer_list  timer;

        int                local;

        int                remote;

};

static int max1617_probe(struct i2c_adapter *adap);

static int max1617_detach(struct i2c_client *device);

static int max1617_command(struct i2c_client *device, unsigned int cmd, void *arg);

static void max1617_inc_use(struct i2c_client *device);

static void max1617_dec_use(struct i2c_client *device);

struct i2c_driver i2c_driver_max1617 = {

        name:           IF_NAME,

        id:             I2C_DRIVERID_MAX1617,

        flags:          I2C_DF_NOTIFY,

        attach_adapter: max1617_probe,

        detach_client:  max1617_detach,

        command:        max1617_command,

        inc_use:        max1617_inc_use,

        dec_use:        max1617_dec_use

};

\

static int max1617_read(struct i2c_client *client, unsigned char subaddr)

{

        return i2c_smbus_read_byte_data(client, subaddr);

}

/* poll the device, check for temperature/status changes */

static void max1617_update(unsigned long arg)

{

        struct max1617_info *m = (struct max1617_info *)arg;

        int status, remote, local;

        char statstr[50];

        status = max1617_read(m->client, MAX1617_STATUS);

        remote = max1617_read(m->client, MAX1617_REMOTE);

        local  = max1617_read(m->client, MAX1617_LOCAL);

        if (status < 0 || remote < 0 || local < 0) {

                printk(KERN_ERR IF_NAME ": sensor device did not respond.\n");

        } else {

                statstr[0] = 0;

                if (status & 0x80) strcat(statstr,"Busy ");

                if (status & 0x40) strcat(statstr,"HiTempLcl ");

                if (status & 0x20) strcat(statstr,"LoTempLcl ");

                if (status & 0x10) strcat(statstr,"HiTempRem ");

                if (status & 0x08) strcat(statstr,"LoTempRem ");

                if (status & 0x04) strcat(statstr,"Fault ");

                if (max1617_verbose || (local != m->local) || (remote != m->remote)) {

                        printk(KERN_DEBUG IF_NAME ": Temperature - CPU: %dC  Board: %dC  Status:%02X [ %s]\n",

                               remote, local, status, statstr);

                }

                m->local = local;

                m->remote = remote;

                mod_timer(&m->timer, jiffies + (HZ * MAX1617_POLL_PERIOD));

        }

}

/* attach to an instance of the device that was probed on a bus */

static int max1617_attach(struct i2c_adapter *adap, int addr, unsigned short flags, int kind)

{

        struct max1617_info *m;

        struct i2c_client   *client;

        int err;

        client = kmalloc(sizeof(*client), GFP_KERNEL);

        if (client == NULL)

                return -ENOMEM;

        client->adapter = adap;

        client->addr = addr;

        client->driver = &i2c_driver_max1617;

        sprintf(client->name, "%s-%x", IF_NAME, addr);

        if ((err = i2c_attach_client(client)) < 0) {

                kfree(client);

                return err;

        }

        m = kmalloc(sizeof(*m), GFP_KERNEL);

        if (m == NULL) {

                i2c_detach_client(client);

                kfree(client);

                return -ENOMEM;

        }

        m->client = client;

        m->remote = m->local = 0;

        init_timer(&m->timer);

        m->timer.data = (unsigned long)m;

        m->timer.function = max1617_update;

        if (max1617_polling) {

                m->timer.expires = jiffies + (HZ * MAX1617_POLL_PERIOD);

                add_timer(&m->timer);

        }

        client->data = m;

        return 0;

}

/* initiate probing on a particular bus */

static int max1617_probe(struct i2c_adapter *adap)

{

        /* Look for this device on the given adapter (bus) */

        if (adap->id == (I2C_ALGO_SIBYTE | I2C_HW_SIBYTE))

                return i2c_probe(adap, &addr_data, &max1617_attach);

        else

                return 0;

}

static int max1617_detach(struct i2c_client *device)

{

        struct max1617_info *m = (struct max1617_info *)device->data;

        int rc = 0;

        if ((rc = i2c_detach_client(device)) != 0) {

                printk(IF_NAME "detach failed: %d\n", rc);

        } else {

                kfree(device);

                if (max1617_polling)

                        del_timer(&m->timer);

                kfree(m);

        }

        return rc;

}

static int max1617_command(struct i2c_client *device, unsigned int cmd, void *arg)

{

        return 0;

}

static void max1617_inc_use(struct i2c_client *client)

{

#ifdef MODULE

        MOD_INC_USE_COUNT;

#endif

}

static void max1617_dec_use(struct i2c_client *client)

{

#ifdef MODULE

        MOD_DEC_USE_COUNT;

#endif

}

void i2c_max1617_init(void)

{

        i2c_add_driver(&i2c_driver_max1617);

}

EXPORT_NO_SYMBOLS;

#ifdef MODULE

MODULE_AUTHOR("Kip Walker, Broadcom Corp.");

MODULE_DESCRIPTION("Max 1617 temperature sensor for SiByte SOC boards");

MODULE_LICENSE("GPL");

int init_module(void)

{

        i2c_max1617_init();

        return 0;

}

void cleanup_module(void)

{

        i2c_del_driver(&i2c_driver_max1617);

}

#endif