* Re: [lm-sensors] [PATCH] Added driver for Maxim MAX6639
2011-01-18 14:41 [lm-sensors] [PATCH] Added driver for Maxim MAX6639 stigge
@ 2011-01-18 16:31 ` Guenter Roeck
2011-01-19 16:29 ` stigge
` (6 subsequent siblings)
7 siblings, 0 replies; 9+ messages in thread
From: Guenter Roeck @ 2011-01-18 16:31 UTC (permalink / raw)
To: lm-sensors
On Tue, Jan 18, 2011 at 09:41:51AM -0500, stigge@antcom.de wrote:
> 2-Channel Temperature Monitor with Dual PWM Fan-Speed Controller
>
> Signed-off-by: Roland Stigge <stigge@antcom.de>
>
Bunch of comments below. This is not a complete review; the driver will need
some cleanup to enable that.
> diff --git a/Documentation/hwmon/max6639 b/Documentation/hwmon/max6639
> new file mode 100644
> index 0000000..2352e54
> --- /dev/null
> +++ b/Documentation/hwmon/max6639
> @@ -0,0 +1,39 @@
> +Kernel driver max6639
> +==========> +
> +Supported chips:
> + * Maxim MAX6639
> + Prefix: 'max6639'
> + Addresses scanned: I2C 0x2c, 0x2e, 0x2f
> + Datasheet: http://pdfserv.maxim-ic.com/en/ds/MAX6639.pdf
> +
> +Authors:
> + He Changqing <hechangqing@semptian.com>
> + Roland Stigge <stigge@antcom.de>
> +
> +Description
> +-----------
> +
> +This driver implements support for the Maxim MAX6639. This chip is a 2-channel
> +temperature monitor with dual PWM fan speed controller. It can monitor its own
> +temperature and one external diode-connected transistor or two external
> +diode-connected transistors.
> +
> +The following device attributes are implemented via sysfs:
> +
> +Attribute R/W Contents
> +----------------------------------------------------------------------------
> +temp1_input R Temperature channel 1 input (0..150 C)
> +temp2_input R Temperature channel 2 input (0..150 C)
> +temp1_max RW Set THERM temperature for input 1 (in C, see datasheet)
> +temp2_max RW Set THERM temperature for input 2 (in C, see datasheet)
> +temp1_crit RW Set ALERM temperature for input 1 (in C, see datasheet)
> +temp2_crit RW Set ALARM temperature for input 2 (in C, see datasheet)
> +temp1_emergency RW Set OT temperature for input 1 (in C, see datasheet)
> +temp2_emergency RW Set OT temperature for input 2 (in C, see datasheet)
> +pwm1 RW Fan 1 target duty cycle (0..255)
> +pwm2 RW Fan 2 target duty cycle (0..255)
> +fan1_input R TACH1 fan tachometer input (in RPM)
> +fan2_input R TACH2 fan tachometer input (in RPM)
> +fan1_div RW Fan 1 divisor (adjust to fan: e.g. 4 pulses per cycle)
> +fan2_div RW Fan 2 divisor (adjust to fan: e.g. 4 pulses per cycle)
> diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig
> index a56f6ad..8eb116c 100644
> --- a/drivers/hwmon/Kconfig
> +++ b/drivers/hwmon/Kconfig
> @@ -674,6 +674,16 @@ config SENSORS_MAX1619
> This driver can also be built as a module. If so, the module
> will be called max1619.
>
> +config SENSORS_MAX6639
> + tristate "Maxim MAX6639 sensor chip"
> + depends on I2C && EXPERIMENTAL
> + help
> + If you say yes here you get support for the MAX6639
> + sensor chips.
> +
> + This driver can also be built as a module. If so, the module
> + will be called max6639.
> +
> config SENSORS_MAX6650
> tristate "Maxim MAX6650 sensor chip"
> depends on I2C && EXPERIMENTAL
> diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile
> index 2479b3d..a85fa3f 100644
> --- a/drivers/hwmon/Makefile
> +++ b/drivers/hwmon/Makefile
> @@ -83,6 +83,7 @@ obj-$(CONFIG_SENSORS_LTC4245) += ltc4245.o
> obj-$(CONFIG_SENSORS_LTC4261) += ltc4261.o
> obj-$(CONFIG_SENSORS_MAX1111) += max1111.o
> obj-$(CONFIG_SENSORS_MAX1619) += max1619.o
> +obj-$(CONFIG_SENSORS_MAX6639) += max6639.o
> obj-$(CONFIG_SENSORS_MAX6650) += max6650.o
> obj-$(CONFIG_SENSORS_MC13783_ADC)+= mc13783-adc.o
> obj-$(CONFIG_SENSORS_PC87360) += pc87360.o
> diff --git a/drivers/hwmon/max6639.c b/drivers/hwmon/max6639.c
> new file mode 100644
> index 0000000..266a3c0
> --- /dev/null
> +++ b/drivers/hwmon/max6639.c
> @@ -0,0 +1,537 @@
> +/*
> + * max6639.c - Support for Maxim MAX6639
> + *
> + * 2-Channel Temperature Monitor with Dual PWM Fan-Speed Controller
> + *
> + * Copyright (C) 1998, 1999 Frodo Looijaard <frodol@dds.nl>
> + * and Philip Edelbrock <phil@netroedge.com>
> + * Copyright (C) 2010 He Changqing <hechangqing@semptian.com>
> + * Copyright (C) 2010, 2011 Roland Stigge <stigge@antcom.de>
> + *
> + * Ported to Linux 2.6 by Tiago Sousa <mirage@kaotik.org>
> + * Ported to Linux 2.6.37 by Roland Stigge <stigge@antcom.de>
> + *
Really, or is this a leftover from the original driver (lm80, maybe) ?
Please don't just copy such stuff, but state instead which driver this
one is based on.
> + * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
> + */
> +
> +#include <linux/module.h>
> +#include <linux/init.h>
> +#include <linux/slab.h>
> +#include <linux/jiffies.h>
> +#include <linux/i2c.h>
> +#include <linux/hwmon.h>
> +#include <linux/hwmon-sysfs.h>
> +#include <linux/err.h>
> +#include <linux/mutex.h>
> +
> +/* Addresses to scan */
> +static unsigned short normal_i2c[] = { 0x2c, 0x2e, 0x2f, I2C_CLIENT_END };
> +
> +/* The MAX6639 registers, valid channel numbers: 0, 1 */
> +#define MAX6639_REG_
Unused define
> +#define MAX6639_REG_TEMP(ch) (0x00 + ch)
> +#define MAX6639_REG_STATUS 0x02
> +#define MAX6639_REG_OUTPUT_MASK 0x03
> +#define MAX6639_REG_GCONFIG 0x04
> +#define MAX6639_REG_TEMP_EXT(ch) (0x05 + ch)
> +#define MAX6639_REG_ALERT_LIMIT(ch) (0x08 + ch)
> +#define MAX6639_REG_OT_LIMIT(ch) (0x0A + ch)
> +#define MAX6639_REG_THERM_LIMIT(ch) (0x0C + ch)
> +#define MAX6639_REG_FAN_CONFIG1(ch) (0x10 + ch * 4)
> +#define MAX6639_REG_FAN_CONFIG2a(ch) (0x11 + ch * 4)
> +#define MAX6639_REG_FAN_CONFIG2b(ch) (0x12 + ch * 4)
> +#define MAX6639_REG_FAN_CONFIG3(ch) (0x13 + ch * 4)
> +#define MAX6639_REG_FAN_CNT(ch) (0x20 + ch)
> +#define MAX6639_REG_TARGET_CNT(ch) (0x22 + ch)
> +#define MAX6639_REG_FAN_PPR(ch) (0x24 + ch)
> +#define MAX6639_REG_TARGTDUTY(ch) (0x26 + ch)
> +#define MAX6639_REG_FAN_START_TEMP(ch) (0x28 + ch)
> +#define MAX6639_REG_DEVID 0x3D
> +#define MAX6639_REG_MANUID 0x3E
> +#define MAX6639_REG_DEVREV 0x3F
> +
> +/* Register bits */
> +#define MAX6639_GCONFIG_STANDBY 0x80
> +#define MAX6639_GCONFIG_POR 0x40
> +#define MAX6639_GCONFIG_DISABLE_TIMEOUT 0x20
> +#define MAX6639_GCONFIG_CH2_LOCAL 0x10
> +
> +#define MAX6639_FAN_CONFIG1_PWM 0x80
> +
> +#define FAN_FROM_REG(val, div) ((val) = 0 ? -1 : \
> + (val) = 255 ? 0 : (4000 * 30) / ((div) * (val)))
div can be 0, which would cause a division by zero.
> +#define TEMP_LIMIT_TO_REG(val) \
> + SENSORS_LIMIT((val) < 0 ? \
> + ((val) - 500) / 1000 : ((val) + 500) / 1000, 0, 255)
> +
Looking into the chip spec, this looks wrong; the chip only supports positive
temperatures. Please verify.
> +/*
> + * Client data (each client gets its own)
> + */
> +struct max6639_data {
> + struct device *hwmon_dev;
> + struct mutex update_lock;
> + char valid; /* !=0 if following fields are valid */
> + unsigned long last_updated; /* In jiffies */
> +
> + u16 temp[2]; /* Temperature, in 1/8 C, 0..255 C */
> + u8 temp_therm[2]; /* THERM Temperature, 0..255 C (->_max) */
> + u8 temp_alert[2]; /* ALERT Temperature, 0..255 C (->_crit) */
> + u8 temp_ot[2]; /* OT Temperature, 0..255 C (->_emergency) */
> + u8 pwm[2]; /* Register value: Duty cycle 0..120 */
> + u8 fan[2]; /* Register value: TACH count for fans: >0 */
> + u8 fan_div[2]; /* Speed divisor: 1, 2, 4, ... */
> +};
> +
> +static int max6639_read_value(struct i2c_client *client, u8 reg)
> +{
> + return i2c_smbus_read_byte_data(client, reg);
> +}
> +
> +static int max6639_write_value(struct i2c_client *client, u8 reg, u8 value)
> +{
> + return i2c_smbus_write_byte_data(client, reg, value);
> +}
> +
> +static struct max6639_data *max6639_update_device(struct device *dev)
> +{
> + struct i2c_client *client = to_i2c_client(dev);
> + struct max6639_data *data = i2c_get_clientdata(client);
> + int i;
> +
> + mutex_lock(&data->update_lock);
> +
> + if (time_after(jiffies, data->last_updated + 2 * HZ) || !data->valid) {
> + dev_dbg(&client->dev, "Starting max6639 update\n");
> +
> + for (i = 0; i < 2; i++) {
> + data->fan[i] = max6639_read_value(client,
> + MAX6639_REG_FAN_CNT(i));
> + data->temp[i] = (max6639_read_value(client,
> + MAX6639_REG_TEMP_EXT(i)) >> 5)
> + | (max6639_read_value(client,
> + MAX6639_REG_TEMP(i)) << 3);
> + data->temp_therm[i] = max6639_read_value(client,
> + MAX6639_REG_THERM_LIMIT(i));
> + data->temp_alert[i] = max6639_read_value(client,
> + MAX6639_REG_ALERT_LIMIT(i));
> + data->temp_ot[i] = max6639_read_value(client,
> + MAX6639_REG_OT_LIMIT(i));
> + data->pwm[i] = max6639_read_value(client,
> + MAX6639_REG_TARGTDUTY(i));
> + }
> +
> + data->last_updated = jiffies;
> + data->valid = 1;
> + }
> +
> + mutex_unlock(&data->update_lock);
> +
> + return data;
Would be nicve to get an error return here, similar to other recent drivers.
> +}
> +
> +#define show_temp_input(suffix) \
> +static ssize_t show_temp_input##suffix(struct device *dev, \
> + struct device_attribute *attr, char *buf) \
> +{ \
> + long temp;\
> + struct max6639_data *data = max6639_update_device(dev); \
> + temp = data->temp[suffix - 1] * 125;\
> + return sprintf(buf, "%ld\n", temp); \
> +}
> +show_temp_input(1);
> +show_temp_input(2);
> +
I fail to see the logic here. You define attribute values 6 and 7, but then you
don't use it as far as I can see but define show_temp_input as macro which takes
the attribute index as parameter.
It would be much simpler and easier to understand would be something
along the line of:
static ssize_t show_temp_input(struct device *dev,
struct device_attribute *dev_attr, char *buf)
{
long temp;
struct max6639_data *data = max6639_update_device(dev);
struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
temp = data->temp[attr->index] * 125;
return sprintf(buf, "%ld\n", temp);
}
static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp_input, NULL, 0);
static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp_input, NULL, 1);
Same for all other sensors.
> +#define show_temp_max(suffix) \
> +static ssize_t show_temp_max##suffix(struct device *dev, \
> + struct device_attribute *attr, char *buf) \
> +{ \
> + struct max6639_data *data = max6639_update_device(dev); \
> + return sprintf(buf, "%d\n", (data->temp_therm[suffix - 1] * 1000)); \
> +}
> +show_temp_max(1);
> +show_temp_max(2);
> +
> +#define set_temp_max(suffix) \
> +static ssize_t set_temp_max##suffix(struct device *dev, \
> + struct device_attribute *attr, const char *buf, \
> + size_t count) \
> +{ \
> + struct i2c_client *client = to_i2c_client(dev); \
> + struct max6639_data *data = i2c_get_clientdata(client); \
> + long val; \
> + int res; \
> +\
> + res = strict_strtoul(buf, 10, &val); \
> + if (res) \
> + return res; \
> +\
> + mutex_lock(&data->update_lock); \
> + data->temp_therm[suffix - 1] = TEMP_LIMIT_TO_REG(val); \
> + max6639_write_value(client, MAX6639_REG_THERM_LIMIT(suffix - 1), \
> + data->temp_therm[suffix - 1]); \
> + mutex_unlock(&data->update_lock); \
> + return count; \
> +}
> +set_temp_max(1);
> +set_temp_max(2);
> +
> +#define show_temp_crit(suffix) \
> +static ssize_t show_temp_crit##suffix(struct device *dev, \
> + struct device_attribute *attr, char *buf) \
> +{ \
> + struct max6639_data *data = max6639_update_device(dev); \
> + return sprintf(buf, "%d\n", (data->temp_alert[suffix - 1] * 1000)); \
> +}
> +show_temp_crit(1);
> +show_temp_crit(2);
> +
> +#define set_temp_crit(suffix) \
> +static ssize_t set_temp_crit##suffix(struct device *dev, \
> + struct device_attribute *attr, const char *buf, \
> + size_t count) \
> +{ \
> + struct i2c_client *client = to_i2c_client(dev); \
> + struct max6639_data *data = i2c_get_clientdata(client); \
> + long val; \
> + int res; \
> +\
> + res = strict_strtoul(buf, 10, &val); \
> + if (res) \
> + return res; \
> +\
> + mutex_lock(&data->update_lock); \
> + data->temp_alert[suffix - 1] = TEMP_LIMIT_TO_REG(val); \
> + max6639_write_value(client, MAX6639_REG_THERM_LIMIT(suffix - 1), \
> + data->temp_alert[suffix - 1]); \
> + mutex_unlock(&data->update_lock); \
> + return count; \
> +}
> +set_temp_crit(1);
> +set_temp_crit(2);
> +
> +#define show_temp_emergency(suffix) \
> +static ssize_t show_temp_emergency##suffix(struct device *dev, \
> + struct device_attribute *attr, char *buf) \
> +{ \
> + struct max6639_data *data = max6639_update_device(dev); \
> + return sprintf(buf, "%d\n", (data->temp_ot[suffix - 1] * 1000)); \
> +}
> +show_temp_emergency(1);
> +show_temp_emergency(2);
> +
> +#define set_temp_emergency(suffix) \
> +static ssize_t set_temp_emergency##suffix(struct device *dev, \
> + struct device_attribute *attr, const char *buf, \
> + size_t count) \
> +{ \
> + struct i2c_client *client = to_i2c_client(dev); \
> + struct max6639_data *data = i2c_get_clientdata(client); \
> + long val; \
> + int res; \
> +\
> + res = strict_strtoul(buf, 10, &val); \
> + if (res) \
> + return res; \
> +\
> + mutex_lock(&data->update_lock); \
> + data->temp_ot[suffix - 1] = TEMP_LIMIT_TO_REG(val); \
> + max6639_write_value(client, MAX6639_REG_THERM_LIMIT(suffix - 1), \
> + data->temp_ot[suffix - 1]); \
> + mutex_unlock(&data->update_lock); \
> + return count; \
> +}
> +set_temp_emergency(1);
> +set_temp_emergency(2);
> +
> +#define show_pwm(suffix) \
> +static ssize_t show_pwm##suffix(struct device *dev, \
> + struct device_attribute *attr, char *buf) \
> +{ \
> + struct max6639_data *data = max6639_update_device(dev); \
> + return sprintf(buf, "%d\n", data->pwm[suffix - 1] * 255 / 120); \
> +}
> +show_pwm(1);
> +show_pwm(2);
> +
> +#define set_pwm(suffix) \
> +static ssize_t set_pwm##suffix(struct device *dev, \
> + struct device_attribute *attr, const char *buf, \
> + size_t count) \
> +{ \
> + struct i2c_client *client = to_i2c_client(dev); \
> + struct max6639_data *data = i2c_get_clientdata(client); \
> + long val; \
> + int res; \
> +\
> + res = strict_strtoul(buf, 10, &val); \
> + if (res) \
> + return res; \
> +\
> + mutex_lock(&data->update_lock); \
> + data->pwm[suffix - 1] = (u8)(val * 120 / 255); \
> + max6639_write_value(client, MAX6639_REG_TARGTDUTY(suffix - 1), \
> + data->pwm[suffix - 1]); \
> + mutex_unlock(&data->update_lock); \
> + return count; \
> +}
> +set_pwm(1);
> +set_pwm(2);
> +
> +#define show_fan_input(suffix) \
> +static ssize_t show_fan_input##suffix(struct device *dev, \
> + struct device_attribute *attr, char *buf) \
> +{ \
> + struct max6639_data *data = max6639_update_device(dev); \
> + return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[suffix - 1], \
> + data->fan_div[suffix - 1])); \
> +}
> +show_fan_input(1);
> +show_fan_input(2);
> +
> +#define show_fan_div(suffix) \
> +static ssize_t show_fan_div##suffix(struct device *dev, \
> + struct device_attribute *attr, char *buf) \
> +{ \
> + struct max6639_data *data = max6639_update_device(dev); \
> + return sprintf(buf, "%d\n", (int)(data->fan_div[suffix - 1])); \
> +}
> +show_fan_div(1);
> +show_fan_div(2);
> +
> +#define set_fan_div(suffix) \
> +static ssize_t set_fan_div##suffix(struct device *dev, \
> + struct device_attribute *attr, const char *buf, size_t count) \
> +{ \
> + struct i2c_client *client = to_i2c_client(dev); \
> + struct max6639_data *data = i2c_get_clientdata(client); \
> + long val; \
> + int res; \
> +\
> + res = strict_strtoul(buf, 10, &val); \
> + if (res) \
> + return res; \
> +\
> + mutex_lock(&data->update_lock); \
> + data->fan_div[suffix - 1] = (u8) val; \
The idea for fan_div is to write it into a chip register. All you do with it is to
use it as divider for calculating rpm. Doesn't look right. Besides, it can be any
arbitrary value including 0, causing a division by zero.
> + mutex_unlock(&data->update_lock); \
> + return count; \
> +}
> +set_fan_div(1);
> +set_fan_div(2);
> +
> +static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp_input1, NULL, 6);
> +static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp_input2, NULL, 7);
> +static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp_max1,
> + set_temp_max1, 8);
> +static SENSOR_DEVICE_ATTR(temp2_max, S_IWUSR | S_IRUGO, show_temp_max2,
> + set_temp_max2, 10);
> +static SENSOR_DEVICE_ATTR(temp1_crit, S_IWUSR | S_IRUGO, show_temp_crit1,
> + set_temp_crit1, 8);
> +static SENSOR_DEVICE_ATTR(temp2_crit, S_IWUSR | S_IRUGO, show_temp_crit2,
> + set_temp_crit2, 10);
> +static SENSOR_DEVICE_ATTR(temp1_emergency, S_IWUSR | S_IRUGO,
> + show_temp_emergency1, set_temp_emergency1, 8);
> +static SENSOR_DEVICE_ATTR(temp2_emergency, S_IWUSR | S_IRUGO,
> + show_temp_emergency2, set_temp_emergency2, 10);
> +static SENSOR_DEVICE_ATTR(pwm1, S_IWUSR | S_IRUGO, show_pwm1, set_pwm1, 2);
> +static SENSOR_DEVICE_ATTR(pwm2, S_IWUSR | S_IRUGO, show_pwm2, set_pwm2, 3);
> +static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan_input1, NULL, 4);
> +static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, show_fan_input2, NULL, 5);
> +static SENSOR_DEVICE_ATTR(fan1_div, S_IWUSR | S_IRUGO, show_fan_div1,
> + set_fan_div1, 0);
> +static SENSOR_DEVICE_ATTR(fan2_div, S_IWUSR | S_IRUGO, show_fan_div2,
> + set_fan_div2, 1);
> +
> +static struct attribute *max6639_attributes[] = {
> + &sensor_dev_attr_temp1_input.dev_attr.attr,
> + &sensor_dev_attr_temp2_input.dev_attr.attr,
> + &sensor_dev_attr_temp1_max.dev_attr.attr,
> + &sensor_dev_attr_temp2_max.dev_attr.attr,
> + &sensor_dev_attr_temp1_crit.dev_attr.attr,
> + &sensor_dev_attr_temp2_crit.dev_attr.attr,
> + &sensor_dev_attr_temp1_emergency.dev_attr.attr,
> + &sensor_dev_attr_temp2_emergency.dev_attr.attr,
> + &sensor_dev_attr_pwm1.dev_attr.attr,
> + &sensor_dev_attr_pwm2.dev_attr.attr,
> + &sensor_dev_attr_fan1_input.dev_attr.attr,
> + &sensor_dev_attr_fan2_input.dev_attr.attr,
> + &sensor_dev_attr_fan1_div.dev_attr.attr,
> + &sensor_dev_attr_fan2_div.dev_attr.attr,
> + NULL
> +};
> +
> +static const struct attribute_group max6639_group = {
> + .attrs = max6639_attributes,
> +};
> +
> +/* Called when we have found a new max6639. */
> +static void max6639_init_client(struct i2c_client *client)
> +{
> + int i;
> +
> + /* Reset chip to default values */
> + max6639_write_value(client, MAX6639_REG_GCONFIG, MAX6639_GCONFIG_POR);
> +
> + for (i = 0; i < 2; i++) {
> + /* Fans config 4000 RPM, PWM */
> + max6639_write_value(client, MAX6639_REG_FAN_CONFIG1(i),
> + MAX6639_FAN_CONFIG1_PWM | 0x01);
Per chip spec, this should be dymamic such that the read value for rpm is
between 30 and 160. Might bw worthwhile thinking about it.
> + /* Fans pulse per revolution is 2 */
> + max6639_write_value(client, MAX6639_REG_FAN_PPR(i), 0x40);
Should this be the register to write when fan_div is set ? But then why do you initialize
fan_div with 1, not 2 ?
> + /* Fans PWM polarity high */
> + max6639_write_value(client, MAX6639_REG_FAN_CONFIG2a(i), 0x02);
Does this assume a given HW ? What if some other HW uses negative polarity ?
> + /* Max. temp. 80C */
> + max6639_write_value(client, MAX6639_REG_THERM_LIMIT(i), 80);
> + /* PWM 120/120 (i.e. 100%) */
> + max6639_write_value(client, MAX6639_REG_TARGTDUTY(i), 120);
> + }
> + /* Start monitoring */
> + max6639_write_value(client, MAX6639_REG_GCONFIG,
> + MAX6639_GCONFIG_DISABLE_TIMEOUT | MAX6639_GCONFIG_CH2_LOCAL);
> +}
> +
> +/* Return 0 if detection is successful, -ENODEV otherwise */
> +static int max6639_detect(struct i2c_client *client,
> + struct i2c_board_info *info)
> +{
> + struct i2c_adapter *adapter = client->adapter;
> + int dev_id, manu_id;
> +
> + if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
> + return -ENODEV;
> +
> + /* Actual detection via device and manufacturer ID */
> + dev_id = max6639_read_value(client, MAX6639_REG_DEVID);
> + manu_id = max6639_read_value(client, MAX6639_REG_MANUID);
> + if (dev_id != 0x58 || manu_id != 0x4D) {
> + printk(KERN_ERR "Bad DevId/ManuID: 0x%02x/0x%02x!\n", dev_id,
> + manu_id);
No good. There can be other chips at the same I2C address. With this, there will be lots
of unnecessary error messages.
> + return -ENODEV;
> + }
> +
> + strlcpy(info->type, "max6639", I2C_NAME_SIZE);
> +
> + return 0;
> +}
> +
> +static int max6639_probe(struct i2c_client *client,
> + const struct i2c_device_id *id)
> +{
> + struct max6639_data *data;
> + int err;
> +
> + data = kzalloc(sizeof(struct max6639_data), GFP_KERNEL);
> + if (!data) {
> + err = -ENOMEM;
> + goto exit;
> + }
> +
> + i2c_set_clientdata(client, data);
> + mutex_init(&data->update_lock);
> +
> + /* Initialize the max6639 chip */
> + max6639_init_client(client);
> +
> + data->fan_div[0] = 1;
> + data->fan_div[1] = 1;
> +
> + /* Register sysfs hooks */
> + err = sysfs_create_group(&client->dev.kobj, &max6639_group);
> + if (err)
> + goto error_free;
> +
> + data->hwmon_dev = hwmon_device_register(&client->dev);
> + if (IS_ERR(data->hwmon_dev)) {
> + err = PTR_ERR(data->hwmon_dev);
> + goto error_remove;
> + }
> + return 0;
> +
> +error_remove:
> + sysfs_remove_group(&client->dev.kobj, &max6639_group);
> +error_free:
> + kfree(data);
> +exit:
> + return err;
> +}
> +
> +static int max6639_remove(struct i2c_client *client)
> +{
> + struct max6639_data *data = i2c_get_clientdata(client);
> +
> + hwmon_device_unregister(data->hwmon_dev);
> + sysfs_remove_group(&client->dev.kobj, &max6639_group);
> +
> + kfree(data);
> + return 0;
> +}
> +
> +static int max6639_suspend(struct i2c_client *client, pm_message_t mesg)
> +{
> + int data = max6639_read_value(client, MAX6639_REG_GCONFIG);
> + if (data < 0)
> + return data;
> +
> + return max6639_write_value(client,
> + MAX6639_REG_GCONFIG, data | MAX6639_GCONFIG_STANDBY);
> +}
> +
> +static int max6639_resume(struct i2c_client *client)
> +{
> + int data = max6639_read_value(client, MAX6639_REG_GCONFIG);
> + if (data < 0)
> + return data;
> +
> + return max6639_write_value(client,
> + MAX6639_REG_GCONFIG, data & ~MAX6639_GCONFIG_STANDBY);
> +}
> +
> +static const struct i2c_device_id max6639_id[] = {
> + {"max6639", 0},
> + {}
> +};
> +
> +MODULE_DEVICE_TABLE(i2c, max6639_id);
> +
> +static struct i2c_driver max6639_driver = {
> + .class = I2C_CLASS_HWMON,
> + .driver = {
> + .name = "max6639",
> + },
> + .probe = max6639_probe,
> + .remove = max6639_remove,
> + .suspend = max6639_suspend,
> + .resume = max6639_resume,
> + .id_table = max6639_id,
> + .detect = max6639_detect,
> + .address_list = normal_i2c,
> +};
> +
> +static int __init sensors_max6639_init(void)
> +{
> + return i2c_add_driver(&max6639_driver);
> +}
> +
> +static void __exit sensors_max6639_exit(void)
> +{
> + i2c_del_driver(&max6639_driver);
> +}
> +
> +MODULE_AUTHOR("Roland Stigge <stigge@antcom.de>");
> +MODULE_DESCRIPTION("max6639 driver");
> +MODULE_LICENSE("GPL");
> +
> +module_init(sensors_max6639_init);
> +module_exit(sensors_max6639_exit);
Just wondering ... why the sensors_ prefix here ?
>
> _______________________________________________
> lm-sensors mailing list
> lm-sensors@lm-sensors.org
> http://lists.lm-sensors.org/mailman/listinfo/lm-sensors
_______________________________________________
lm-sensors mailing list
lm-sensors@lm-sensors.org
http://lists.lm-sensors.org/mailman/listinfo/lm-sensors
^ permalink raw reply [flat|nested] 9+ messages in thread* [lm-sensors] [PATCH] Added driver for Maxim MAX6639
2011-01-18 14:41 [lm-sensors] [PATCH] Added driver for Maxim MAX6639 stigge
2011-01-18 16:31 ` Guenter Roeck
@ 2011-01-19 16:29 ` stigge
2011-01-19 16:30 ` Roland Stigge
` (5 subsequent siblings)
7 siblings, 0 replies; 9+ messages in thread
From: stigge @ 2011-01-19 16:29 UTC (permalink / raw)
To: lm-sensors
2-Channel Temperature Monitor with Dual PWM Fan-Speed Controller
Signed-off-by: Roland Stigge <stigge@antcom.de>
diff --git a/Documentation/hwmon/max6639 b/Documentation/hwmon/max6639
new file mode 100644
index 0000000..debb3f0
--- /dev/null
+++ b/Documentation/hwmon/max6639
@@ -0,0 +1,37 @@
+Kernel driver max6639
+==========+
+Supported chips:
+ * Maxim MAX6639
+ Prefix: 'max6639'
+ Addresses scanned: I2C 0x2c, 0x2e, 0x2f
+ Datasheet: http://pdfserv.maxim-ic.com/en/ds/MAX6639.pdf
+
+Authors:
+ He Changqing <hechangqing@semptian.com>
+ Roland Stigge <stigge@antcom.de>
+
+Description
+-----------
+
+This driver implements support for the Maxim MAX6639. This chip is a 2-channel
+temperature monitor with dual PWM fan speed controller. It can monitor its own
+temperature and one external diode-connected transistor or two external
+diode-connected transistors.
+
+The following device attributes are implemented via sysfs:
+
+Attribute R/W Contents
+----------------------------------------------------------------------------
+temp1_input R Temperature channel 1 input (0..150 C)
+temp2_input R Temperature channel 2 input (0..150 C)
+temp1_max RW Set THERM temperature for input 1 (in C, see datasheet)
+temp2_max RW Set THERM temperature for input 2 (in C, see datasheet)
+temp1_crit RW Set ALERM temperature for input 1 (in C, see datasheet)
+temp2_crit RW Set ALARM temperature for input 2 (in C, see datasheet)
+temp1_emergency RW Set OT temperature for input 1 (in C, see datasheet)
+temp2_emergency RW Set OT temperature for input 2 (in C, see datasheet)
+pwm1 RW Fan 1 target duty cycle (0..255)
+pwm2 RW Fan 2 target duty cycle (0..255)
+fan1_input R TACH1 fan tachometer input (in RPM)
+fan2_input R TACH2 fan tachometer input (in RPM)
diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig
index a56f6ad..8eb116c 100644
--- a/drivers/hwmon/Kconfig
+++ b/drivers/hwmon/Kconfig
@@ -674,6 +674,16 @@ config SENSORS_MAX1619
This driver can also be built as a module. If so, the module
will be called max1619.
+config SENSORS_MAX6639
+ tristate "Maxim MAX6639 sensor chip"
+ depends on I2C && EXPERIMENTAL
+ help
+ If you say yes here you get support for the MAX6639
+ sensor chips.
+
+ This driver can also be built as a module. If so, the module
+ will be called max6639.
+
config SENSORS_MAX6650
tristate "Maxim MAX6650 sensor chip"
depends on I2C && EXPERIMENTAL
diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile
index 2479b3d..a85fa3f 100644
--- a/drivers/hwmon/Makefile
+++ b/drivers/hwmon/Makefile
@@ -83,6 +83,7 @@ obj-$(CONFIG_SENSORS_LTC4245) += ltc4245.o
obj-$(CONFIG_SENSORS_LTC4261) += ltc4261.o
obj-$(CONFIG_SENSORS_MAX1111) += max1111.o
obj-$(CONFIG_SENSORS_MAX1619) += max1619.o
+obj-$(CONFIG_SENSORS_MAX6639) += max6639.o
obj-$(CONFIG_SENSORS_MAX6650) += max6650.o
obj-$(CONFIG_SENSORS_MC13783_ADC)+= mc13783-adc.o
obj-$(CONFIG_SENSORS_PC87360) += pc87360.o
diff --git a/drivers/hwmon/max6639.c b/drivers/hwmon/max6639.c
new file mode 100644
index 0000000..64e77f9
--- /dev/null
+++ b/drivers/hwmon/max6639.c
@@ -0,0 +1,567 @@
+/*
+ * max6639.c - Support for Maxim MAX6639
+ *
+ * 2-Channel Temperature Monitor with Dual PWM Fan-Speed Controller
+ *
+ * Copyright (C) 2010, 2011 Roland Stigge <stigge@antcom.de>
+ *
+ * based on the initial MAX6639 support from septian.net
+ * by He Changqing <hechangqing@semptian.com>
+ *
+ * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/jiffies.h>
+#include <linux/i2c.h>
+#include <linux/hwmon.h>
+#include <linux/hwmon-sysfs.h>
+#include <linux/err.h>
+#include <linux/mutex.h>
+#include <linux/i2c/max6639.h>
+
+/* Addresses to scan */
+static unsigned short normal_i2c[] = { 0x2c, 0x2e, 0x2f, I2C_CLIENT_END };
+
+/* The MAX6639 registers, valid channel numbers: 0, 1 */
+#define MAX6639_REG_TEMP(ch) (0x00 + ch)
+#define MAX6639_REG_STATUS 0x02
+#define MAX6639_REG_OUTPUT_MASK 0x03
+#define MAX6639_REG_GCONFIG 0x04
+#define MAX6639_REG_TEMP_EXT(ch) (0x05 + ch)
+#define MAX6639_REG_ALERT_LIMIT(ch) (0x08 + ch)
+#define MAX6639_REG_OT_LIMIT(ch) (0x0A + ch)
+#define MAX6639_REG_THERM_LIMIT(ch) (0x0C + ch)
+#define MAX6639_REG_FAN_CONFIG1(ch) (0x10 + ch * 4)
+#define MAX6639_REG_FAN_CONFIG2a(ch) (0x11 + ch * 4)
+#define MAX6639_REG_FAN_CONFIG2b(ch) (0x12 + ch * 4)
+#define MAX6639_REG_FAN_CONFIG3(ch) (0x13 + ch * 4)
+#define MAX6639_REG_FAN_CNT(ch) (0x20 + ch)
+#define MAX6639_REG_TARGET_CNT(ch) (0x22 + ch)
+#define MAX6639_REG_FAN_PPR(ch) (0x24 + ch)
+#define MAX6639_REG_TARGTDUTY(ch) (0x26 + ch)
+#define MAX6639_REG_FAN_START_TEMP(ch) (0x28 + ch)
+#define MAX6639_REG_DEVID 0x3D
+#define MAX6639_REG_MANUID 0x3E
+#define MAX6639_REG_DEVREV 0x3F
+
+/* Register bits */
+#define MAX6639_GCONFIG_STANDBY 0x80
+#define MAX6639_GCONFIG_POR 0x40
+#define MAX6639_GCONFIG_DISABLE_TIMEOUT 0x20
+#define MAX6639_GCONFIG_CH2_LOCAL 0x10
+
+#define MAX6639_FAN_CONFIG1_PWM 0x80
+
+static int rpm_ranges[] = { 2000, 4000, 8000, 16000 };
+
+#define FAN_FROM_REG(val, div) ((val) = 0 ? -1 : \
+ (val) = 255 ? 0 : (4000 * 30) / ((div + 1) * (val)))
+#define TEMP_LIMIT_TO_REG(val) SENSORS_LIMIT((val) / 1000, 0, 255)
+
+/*
+ * Client data (each client gets its own)
+ */
+struct max6639_data {
+ struct device *hwmon_dev;
+ struct mutex update_lock;
+ char valid; /* !=0 if following fields are valid */
+ unsigned long last_updated; /* In jiffies */
+
+ /* Register values sampled regularly */
+ u16 temp[2]; /* Temperature, in 1/8 C, 0..255 C */
+ u8 fan[2]; /* Register value: TACH count for fans >0 */
+
+ /* Register values only written to */
+ u8 pwm[2]; /* Register value: Duty cycle 0..120 */
+ u8 temp_therm[2]; /* THERM Temperature, 0..255 C (->_max) */
+ u8 temp_alert[2]; /* ALERT Temperature, 0..255 C (->_crit) */
+ u8 temp_ot[2]; /* OT Temperature, 0..255 C (->_emergency) */
+
+ /* Register values initialized only once */
+ u8 ppr[2]; /* Pulses per rotation 0..3 for 1..4 ppr */
+};
+
+static int max6639_read_value(struct i2c_client *client, u8 reg)
+{
+ return i2c_smbus_read_byte_data(client, reg);
+}
+
+static int max6639_write_value(struct i2c_client *client, u8 reg, u8 value)
+{
+ return i2c_smbus_write_byte_data(client, reg, value);
+}
+
+static struct max6639_data *max6639_update_device(struct device *dev)
+{
+ struct i2c_client *client = to_i2c_client(dev);
+ struct max6639_data *data = i2c_get_clientdata(client);
+ struct max6639_data *ret = data;
+ int i;
+
+ mutex_lock(&data->update_lock);
+
+ if (time_after(jiffies, data->last_updated + 2 * HZ) || !data->valid) {
+ int res;
+
+ dev_dbg(&client->dev, "Starting max6639 update\n");
+
+ for (i = 0; i < 2; i++) {
+ res = max6639_read_value(client,
+ MAX6639_REG_FAN_CNT(i));
+ if (res < 0) {
+ ret = ERR_PTR(res);
+ goto abort;
+ }
+ data->fan[i] = res;
+
+ res = (max6639_read_value(client,
+ MAX6639_REG_TEMP_EXT(i)) >> 5)
+ | (max6639_read_value(client,
+ MAX6639_REG_TEMP(i)) << 3);
+ if (res < 0) {
+ ret = ERR_PTR(res);
+ goto abort;
+ }
+ data->temp[i] = res;
+ }
+
+ data->last_updated = jiffies;
+ data->valid = 1;
+ }
+abort:
+ mutex_unlock(&data->update_lock);
+
+ return ret;
+}
+
+static ssize_t show_temp_input(struct device *dev,
+ struct device_attribute *dev_attr, char *buf)
+{
+ long temp;
+ struct max6639_data *data = max6639_update_device(dev);
+ struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
+
+ temp = data->temp[attr->index] * 125;
+ return sprintf(buf, "%ld\n", temp);
+}
+
+static ssize_t show_temp_max(struct device *dev,
+ struct device_attribute *dev_attr, char *buf)
+{
+ struct i2c_client *client = to_i2c_client(dev);
+ struct max6639_data *data = i2c_get_clientdata(client);
+ struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
+
+ return sprintf(buf, "%d\n", (data->temp_therm[attr->index] * 1000));
+}
+
+static ssize_t set_temp_max(struct device *dev,
+ struct device_attribute *dev_attr,
+ const char *buf, size_t count)
+{
+ struct i2c_client *client = to_i2c_client(dev);
+ struct max6639_data *data = i2c_get_clientdata(client);
+ struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
+ unsigned long val;
+ int res;
+
+ res = strict_strtoul(buf, 10, &val);
+ if (res)
+ return res;
+
+ mutex_lock(&data->update_lock);
+ data->temp_therm[attr->index] = TEMP_LIMIT_TO_REG(val);
+ max6639_write_value(client, MAX6639_REG_THERM_LIMIT(attr->index),
+ data->temp_therm[attr->index]);
+ mutex_unlock(&data->update_lock);
+ return count;
+}
+
+static ssize_t show_temp_crit(struct device *dev,
+ struct device_attribute *dev_attr, char *buf)
+{
+ struct i2c_client *client = to_i2c_client(dev);
+ struct max6639_data *data = i2c_get_clientdata(client);
+ struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
+
+ return sprintf(buf, "%d\n", (data->temp_alert[attr->index] * 1000));
+}
+
+static ssize_t set_temp_crit(struct device *dev,
+ struct device_attribute *dev_attr,
+ const char *buf, size_t count)
+{
+ struct i2c_client *client = to_i2c_client(dev);
+ struct max6639_data *data = i2c_get_clientdata(client);
+ struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
+ unsigned long val;
+ int res;
+
+ res = strict_strtoul(buf, 10, &val);
+ if (res)
+ return res;
+
+ mutex_lock(&data->update_lock);
+ data->temp_alert[attr->index] = TEMP_LIMIT_TO_REG(val);
+ max6639_write_value(client, MAX6639_REG_THERM_LIMIT(attr->index),
+ data->temp_alert[attr->index]);
+ mutex_unlock(&data->update_lock);
+ return count;
+}
+
+static ssize_t show_temp_emergency(struct device *dev,
+ struct device_attribute *dev_attr,
+ char *buf)
+{
+ struct i2c_client *client = to_i2c_client(dev);
+ struct max6639_data *data = i2c_get_clientdata(client);
+ struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
+
+ return sprintf(buf, "%d\n", (data->temp_ot[attr->index] * 1000));
+}
+
+static ssize_t set_temp_emergency(struct device *dev,
+ struct device_attribute *dev_attr,
+ const char *buf, size_t count)
+{
+ struct i2c_client *client = to_i2c_client(dev);
+ struct max6639_data *data = i2c_get_clientdata(client);
+ struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
+ unsigned long val;
+ int res;
+
+ res = strict_strtoul(buf, 10, &val);
+ if (res)
+ return res;
+
+ mutex_lock(&data->update_lock);
+ data->temp_ot[attr->index] = TEMP_LIMIT_TO_REG(val);
+ max6639_write_value(client, MAX6639_REG_THERM_LIMIT(attr->index),
+ data->temp_ot[attr->index]);
+ mutex_unlock(&data->update_lock);
+ return count;
+}
+
+static ssize_t show_pwm(struct device *dev,
+ struct device_attribute *dev_attr, char *buf)
+{
+ struct i2c_client *client = to_i2c_client(dev);
+ struct max6639_data *data = i2c_get_clientdata(client);
+ struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
+
+ return sprintf(buf, "%d\n", data->pwm[attr->index] * 255 / 120);
+}
+
+static ssize_t set_pwm(struct device *dev,
+ struct device_attribute *dev_attr,
+ const char *buf, size_t count)
+{
+ struct i2c_client *client = to_i2c_client(dev);
+ struct max6639_data *data = i2c_get_clientdata(client);
+ struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
+ long val;
+ int res;
+
+ res = strict_strtoul(buf, 10, &val);
+ if (res)
+ return res;
+
+ mutex_lock(&data->update_lock);
+ data->pwm[attr->index] = (u8)(val * 120 / 255);
+ max6639_write_value(client, MAX6639_REG_TARGTDUTY(attr->index),
+ data->pwm[attr->index]);
+ mutex_unlock(&data->update_lock);
+ return count;
+}
+
+static ssize_t show_fan_input(struct device *dev,
+ struct device_attribute *dev_attr, char *buf)
+{
+ struct max6639_data *data = max6639_update_device(dev);
+ struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
+
+ return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[attr->index],
+ data->ppr[attr->index]));
+}
+
+static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp_input, NULL, 0);
+static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp_input, NULL, 1);
+static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp_max,
+ set_temp_max, 0);
+static SENSOR_DEVICE_ATTR(temp2_max, S_IWUSR | S_IRUGO, show_temp_max,
+ set_temp_max, 1);
+static SENSOR_DEVICE_ATTR(temp1_crit, S_IWUSR | S_IRUGO, show_temp_crit,
+ set_temp_crit, 0);
+static SENSOR_DEVICE_ATTR(temp2_crit, S_IWUSR | S_IRUGO, show_temp_crit,
+ set_temp_crit, 1);
+static SENSOR_DEVICE_ATTR(temp1_emergency, S_IWUSR | S_IRUGO,
+ show_temp_emergency, set_temp_emergency, 0);
+static SENSOR_DEVICE_ATTR(temp2_emergency, S_IWUSR | S_IRUGO,
+ show_temp_emergency, set_temp_emergency, 1);
+static SENSOR_DEVICE_ATTR(pwm1, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 0);
+static SENSOR_DEVICE_ATTR(pwm2, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 1);
+static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan_input, NULL, 0);
+static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, show_fan_input, NULL, 1);
+
+static struct attribute *max6639_attributes[] = {
+ &sensor_dev_attr_temp1_input.dev_attr.attr,
+ &sensor_dev_attr_temp2_input.dev_attr.attr,
+ &sensor_dev_attr_temp1_max.dev_attr.attr,
+ &sensor_dev_attr_temp2_max.dev_attr.attr,
+ &sensor_dev_attr_temp1_crit.dev_attr.attr,
+ &sensor_dev_attr_temp2_crit.dev_attr.attr,
+ &sensor_dev_attr_temp1_emergency.dev_attr.attr,
+ &sensor_dev_attr_temp2_emergency.dev_attr.attr,
+ &sensor_dev_attr_pwm1.dev_attr.attr,
+ &sensor_dev_attr_pwm2.dev_attr.attr,
+ &sensor_dev_attr_fan1_input.dev_attr.attr,
+ &sensor_dev_attr_fan2_input.dev_attr.attr,
+ NULL
+};
+
+static const struct attribute_group max6639_group = {
+ .attrs = max6639_attributes,
+};
+
+/* returns respective index in rpm_ranges table, -1 on invalid range */
+static int rpm_range_to_reg(int range)
+{
+ int i;
+ int result = -1;
+
+ for (i = 0; i < ARRAY_SIZE(rpm_ranges); i++) {
+ if (rpm_ranges[i] = range)
+ result = i;
+ }
+
+ return result;
+}
+
+static int max6639_init_client(struct i2c_client *client)
+{
+ struct max6639_data *data = i2c_get_clientdata(client);
+ struct max6639_platform_data *max6639_info + client->dev.platform_data;
+ int i;
+ int rpm_range = -1;
+ int err = 0;
+
+ /* Reset chip to default values */
+ err = max6639_write_value(client, MAX6639_REG_GCONFIG,
+ MAX6639_GCONFIG_POR);
+ if (err)
+ goto exit;
+
+ /* RPM range, 4000 by default */
+ if (max6639_info)
+ rpm_range = rpm_range_to_reg(max6639_info->rpm_range);
+ if (rpm_range < 0)
+ rpm_range = 1;
+
+ for (i = 0; i < 2; i++) {
+
+ /* Fans config PWM, RPM */
+ err = max6639_write_value(client, MAX6639_REG_FAN_CONFIG1(i),
+ MAX6639_FAN_CONFIG1_PWM | rpm_range);
+ if (err)
+ goto exit;
+
+ /* Fans pulse per revolution is 2 by default */
+ if (max6639_info)
+ data->ppr[i] = max6639_info->ppr;
+ else
+ data->ppr[i] = 2;
+ data->ppr[i] -= 1;
+ err = max6639_write_value(client, MAX6639_REG_FAN_PPR(i),
+ (data->ppr[i]) << 5);
+ if (err)
+ goto exit;
+
+ /* Fans PWM polarity high by default */
+ if (max6639_info && max6639_info->pwm_polarity = 0)
+ err = max6639_write_value(client,
+ MAX6639_REG_FAN_CONFIG2a(i), 0x00);
+ else
+ err = max6639_write_value(client,
+ MAX6639_REG_FAN_CONFIG2a(i), 0x02);
+ if (err)
+ goto exit;
+
+ /* Max. temp. 80C/90C/100C */
+ data->temp_therm[i] = 80;
+ data->temp_alert[i] = 90;
+ data->temp_ot[i] = 100;
+ err = max6639_write_value(client, MAX6639_REG_THERM_LIMIT(i),
+ data->temp_therm[i]);
+ if (err)
+ goto exit;
+ err = max6639_write_value(client, MAX6639_REG_ALERT_LIMIT(i),
+ data->temp_alert[i]);
+ if (err)
+ goto exit;
+ err = max6639_write_value(client, MAX6639_REG_OT_LIMIT(i),
+ data->temp_ot[i]);
+ if (err)
+ goto exit;
+
+ /* PWM 120/120 (i.e. 100%) */
+ data->pwm[i] = 120;
+ err = max6639_write_value(client, MAX6639_REG_TARGTDUTY(i),
+ data->pwm[i]);
+ if (err)
+ goto exit;
+ }
+ /* Start monitoring */
+ err = max6639_write_value(client, MAX6639_REG_GCONFIG,
+ MAX6639_GCONFIG_DISABLE_TIMEOUT | MAX6639_GCONFIG_CH2_LOCAL);
+exit:
+ return err;
+}
+
+/* Return 0 if detection is successful, -ENODEV otherwise */
+static int max6639_detect(struct i2c_client *client,
+ struct i2c_board_info *info)
+{
+ struct i2c_adapter *adapter = client->adapter;
+ int dev_id, manu_id;
+
+ if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
+ return -ENODEV;
+
+ /* Actual detection via device and manufacturer ID */
+ dev_id = max6639_read_value(client, MAX6639_REG_DEVID);
+ manu_id = max6639_read_value(client, MAX6639_REG_MANUID);
+ if (dev_id != 0x58 || manu_id != 0x4D)
+ return -ENODEV;
+
+ strlcpy(info->type, "max6639", I2C_NAME_SIZE);
+
+ return 0;
+}
+
+static int max6639_probe(struct i2c_client *client,
+ const struct i2c_device_id *id)
+{
+ struct max6639_data *data;
+ int err;
+
+ data = kzalloc(sizeof(struct max6639_data), GFP_KERNEL);
+ if (!data) {
+ err = -ENOMEM;
+ goto exit;
+ }
+
+ i2c_set_clientdata(client, data);
+ mutex_init(&data->update_lock);
+
+ /* Initialize the max6639 chip */
+ err = max6639_init_client(client);
+ if (err < 0)
+ goto error_free;
+
+ /* Register sysfs hooks */
+ err = sysfs_create_group(&client->dev.kobj, &max6639_group);
+ if (err)
+ goto error_free;
+
+ data->hwmon_dev = hwmon_device_register(&client->dev);
+ if (IS_ERR(data->hwmon_dev)) {
+ err = PTR_ERR(data->hwmon_dev);
+ goto error_remove;
+ }
+
+ dev_info(&client->dev, "temperature sensor and fan control found\n");
+
+ return 0;
+
+error_remove:
+ sysfs_remove_group(&client->dev.kobj, &max6639_group);
+error_free:
+ kfree(data);
+exit:
+ return err;
+}
+
+static int max6639_remove(struct i2c_client *client)
+{
+ struct max6639_data *data = i2c_get_clientdata(client);
+
+ hwmon_device_unregister(data->hwmon_dev);
+ sysfs_remove_group(&client->dev.kobj, &max6639_group);
+
+ kfree(data);
+ return 0;
+}
+
+static int max6639_suspend(struct i2c_client *client, pm_message_t mesg)
+{
+ int data = max6639_read_value(client, MAX6639_REG_GCONFIG);
+ if (data < 0)
+ return data;
+
+ return max6639_write_value(client,
+ MAX6639_REG_GCONFIG, data | MAX6639_GCONFIG_STANDBY);
+}
+
+static int max6639_resume(struct i2c_client *client)
+{
+ int data = max6639_read_value(client, MAX6639_REG_GCONFIG);
+ if (data < 0)
+ return data;
+
+ return max6639_write_value(client,
+ MAX6639_REG_GCONFIG, data & ~MAX6639_GCONFIG_STANDBY);
+}
+
+static const struct i2c_device_id max6639_id[] = {
+ {"max6639", 0},
+ {}
+};
+
+MODULE_DEVICE_TABLE(i2c, max6639_id);
+
+static struct i2c_driver max6639_driver = {
+ .class = I2C_CLASS_HWMON,
+ .driver = {
+ .name = "max6639",
+ },
+ .probe = max6639_probe,
+ .remove = max6639_remove,
+ .suspend = max6639_suspend,
+ .resume = max6639_resume,
+ .id_table = max6639_id,
+ .detect = max6639_detect,
+ .address_list = normal_i2c,
+};
+
+static int __init max6639_init(void)
+{
+ return i2c_add_driver(&max6639_driver);
+}
+
+static void __exit max6639_exit(void)
+{
+ i2c_del_driver(&max6639_driver);
+}
+
+MODULE_AUTHOR("Roland Stigge <stigge@antcom.de>");
+MODULE_DESCRIPTION("max6639 driver");
+MODULE_LICENSE("GPL");
+
+module_init(max6639_init);
+module_exit(max6639_exit);
diff --git a/include/linux/i2c/max6639.h b/include/linux/i2c/max6639.h
new file mode 100644
index 0000000..f7323c5
--- /dev/null
+++ b/include/linux/i2c/max6639.h
@@ -0,0 +1,15 @@
+#ifndef _LINUX_MAX6639_H
+#define _LINUX_MAX6639_H
+
+#include <linux/types.h>
+#include <linux/i2c.h>
+
+/* platform data for the MAX6639 temperature sensor and fan control */
+
+struct max6639_platform_data {
+ bool pwm_polarity; /* Polarity low (0) or high (1, default) */
+ int ppr; /* Pulses per rotation 1..4 (default = 1) */
+ int rpm_range; /* 2000, 4000 (default), 8000 or 16000 */
+};
+
+#endif /* _LINUX_MAX6639_H */
_______________________________________________
lm-sensors mailing list
lm-sensors@lm-sensors.org
http://lists.lm-sensors.org/mailman/listinfo/lm-sensors
^ permalink raw reply related [flat|nested] 9+ messages in thread* Re: [lm-sensors] [PATCH] Added driver for Maxim MAX6639
2011-01-18 14:41 [lm-sensors] [PATCH] Added driver for Maxim MAX6639 stigge
2011-01-18 16:31 ` Guenter Roeck
2011-01-19 16:29 ` stigge
@ 2011-01-19 16:30 ` Roland Stigge
2011-01-19 18:11 ` Guenter Roeck
` (4 subsequent siblings)
7 siblings, 0 replies; 9+ messages in thread
From: Roland Stigge @ 2011-01-19 16:30 UTC (permalink / raw)
To: lm-sensors
Hi!
On 01/18/2011 05:31 PM, Guenter Roeck wrote:
>> Signed-off-by: Roland Stigge <stigge@antcom.de>
>>
> Bunch of comments below. This is not a complete review; the driver will need
> some cleanup to enable that.
Thanks for your notes!
I took the max6639.c from He Changqing of semptian.net. Extended and
cleaned it up quite a bit, but surely it was still not enough.
Will send the updated version in a separate patch mail where I
considered all your suggestions.
fan_div in the register and maintained separately is a bit tricky. You
have it in Register 0x24. But also, you have a ratio between "selected
pulses per revolution" and "actual ppr", see page 14, table 7, in the
datasheet. I guess He Changqing tried to model this in the initial
semptian.net version of the driver by handling fan_div independently
from the reg. For now, I'm moving fan_div to platform_data's ppr (pulses
per rotation), because it doesn't fit our sysfs' fan_div definition
(powers of two).
In a future update, I can try to adjust the fan rpm range automatically.
Still need a robust strategy because we need to guard against hardware
failures (what this interface is about in the first place). Also doing
via platform_data's rpm_range for now.
Thanks in advance!
Roland
--
Dipl.-Inf. Roland Stigge
SATCOM Technologies
**********************************************************
WORK Microwave GmbH
Raiffeisenstrasse 12
83607 Holzkirchen
Germany
Tel: +49 8024 6408-0
Fax: +49 8024 6408-40
roland.stigge@work-microwave.de
http://www.work-microwave.de./
Gesch채ftsf체hrer / Managing Directors:
Dr. Andreas Hausotter (CEO), Dr. G체nter Prokoph (CTO)
Sitz / Reg. Office: Holzkirchen, Germany
Reg. HRB M체nchen Nr. 79479
ISO 9001:2008 certificate
This message and any attachments may contain confidential information
and must not be disclosed to a third party without the prior written
consent of Work Microwave GmbH, Germany.
If you have received it erroneously, please discard it and contact us by
return.
**********************************************************
_______________________________________________
lm-sensors mailing list
lm-sensors@lm-sensors.org
http://lists.lm-sensors.org/mailman/listinfo/lm-sensors
^ permalink raw reply [flat|nested] 9+ messages in thread* Re: [lm-sensors] [PATCH] Added driver for Maxim MAX6639
2011-01-18 14:41 [lm-sensors] [PATCH] Added driver for Maxim MAX6639 stigge
` (2 preceding siblings ...)
2011-01-19 16:30 ` Roland Stigge
@ 2011-01-19 18:11 ` Guenter Roeck
2011-01-20 11:00 ` stigge
` (3 subsequent siblings)
7 siblings, 0 replies; 9+ messages in thread
From: Guenter Roeck @ 2011-01-19 18:11 UTC (permalink / raw)
To: lm-sensors
On Wed, 2011-01-19 at 11:29 -0500, stigge@antcom.de wrote:
> 2-Channel Temperature Monitor with Dual PWM Fan-Speed Controller
>
> Signed-off-by: Roland Stigge <stigge@antcom.de>
>
Much better. Comments inline.
> diff --git a/Documentation/hwmon/max6639 b/Documentation/hwmon/max6639
> new file mode 100644
> index 0000000..debb3f0
> --- /dev/null
> +++ b/Documentation/hwmon/max6639
> @@ -0,0 +1,37 @@
> +Kernel driver max6639
> +==========> +
> +Supported chips:
> + * Maxim MAX6639
> + Prefix: 'max6639'
> + Addresses scanned: I2C 0x2c, 0x2e, 0x2f
> + Datasheet: http://pdfserv.maxim-ic.com/en/ds/MAX6639.pdf
> +
> +Authors:
> + He Changqing <hechangqing@semptian.com>
> + Roland Stigge <stigge@antcom.de>
> +
> +Description
> +-----------
> +
> +This driver implements support for the Maxim MAX6639. This chip is a 2-channel
> +temperature monitor with dual PWM fan speed controller. It can monitor its own
> +temperature and one external diode-connected transistor or two external
> +diode-connected transistors.
> +
> +The following device attributes are implemented via sysfs:
> +
> +Attribute R/W Contents
> +----------------------------------------------------------------------------
> +temp1_input R Temperature channel 1 input (0..150 C)
> +temp2_input R Temperature channel 2 input (0..150 C)
> +temp1_max RW Set THERM temperature for input 1 (in C, see datasheet)
> +temp2_max RW Set THERM temperature for input 2 (in C, see datasheet)
> +temp1_crit RW Set ALERM temperature for input 1 (in C, see datasheet)
> +temp2_crit RW Set ALARM temperature for input 2 (in C, see datasheet)
> +temp1_emergency RW Set OT temperature for input 1 (in C, see datasheet)
> +temp2_emergency RW Set OT temperature for input 2 (in C, see datasheet)
> +pwm1 RW Fan 1 target duty cycle (0..255)
> +pwm2 RW Fan 2 target duty cycle (0..255)
> +fan1_input R TACH1 fan tachometer input (in RPM)
> +fan2_input R TACH2 fan tachometer input (in RPM)
> diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig
> index a56f6ad..8eb116c 100644
> --- a/drivers/hwmon/Kconfig
> +++ b/drivers/hwmon/Kconfig
> @@ -674,6 +674,16 @@ config SENSORS_MAX1619
> This driver can also be built as a module. If so, the module
> will be called max1619.
>
> +config SENSORS_MAX6639
> + tristate "Maxim MAX6639 sensor chip"
> + depends on I2C && EXPERIMENTAL
> + help
> + If you say yes here you get support for the MAX6639
> + sensor chips.
> +
> + This driver can also be built as a module. If so, the module
> + will be called max6639.
> +
> config SENSORS_MAX6650
> tristate "Maxim MAX6650 sensor chip"
> depends on I2C && EXPERIMENTAL
> diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile
> index 2479b3d..a85fa3f 100644
> --- a/drivers/hwmon/Makefile
> +++ b/drivers/hwmon/Makefile
> @@ -83,6 +83,7 @@ obj-$(CONFIG_SENSORS_LTC4245) += ltc4245.o
> obj-$(CONFIG_SENSORS_LTC4261) += ltc4261.o
> obj-$(CONFIG_SENSORS_MAX1111) += max1111.o
> obj-$(CONFIG_SENSORS_MAX1619) += max1619.o
> +obj-$(CONFIG_SENSORS_MAX6639) += max6639.o
> obj-$(CONFIG_SENSORS_MAX6650) += max6650.o
> obj-$(CONFIG_SENSORS_MC13783_ADC)+= mc13783-adc.o
> obj-$(CONFIG_SENSORS_PC87360) += pc87360.o
> diff --git a/drivers/hwmon/max6639.c b/drivers/hwmon/max6639.c
> new file mode 100644
> index 0000000..64e77f9
> --- /dev/null
> +++ b/drivers/hwmon/max6639.c
> @@ -0,0 +1,567 @@
> +/*
> + * max6639.c - Support for Maxim MAX6639
> + *
> + * 2-Channel Temperature Monitor with Dual PWM Fan-Speed Controller
> + *
> + * Copyright (C) 2010, 2011 Roland Stigge <stigge@antcom.de>
> + *
> + * based on the initial MAX6639 support from septian.net
semptian.net
> + * by He Changqing <hechangqing@semptian.com>
> + *
> + * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
> + */
> +
> +#include <linux/module.h>
> +#include <linux/init.h>
> +#include <linux/slab.h>
> +#include <linux/jiffies.h>
> +#include <linux/i2c.h>
> +#include <linux/hwmon.h>
> +#include <linux/hwmon-sysfs.h>
> +#include <linux/err.h>
> +#include <linux/mutex.h>
> +#include <linux/i2c/max6639.h>
> +
> +/* Addresses to scan */
> +static unsigned short normal_i2c[] = { 0x2c, 0x2e, 0x2f, I2C_CLIENT_END };
> +
> +/* The MAX6639 registers, valid channel numbers: 0, 1 */
> +#define MAX6639_REG_TEMP(ch) (0x00 + ch)
> +#define MAX6639_REG_STATUS 0x02
> +#define MAX6639_REG_OUTPUT_MASK 0x03
> +#define MAX6639_REG_GCONFIG 0x04
> +#define MAX6639_REG_TEMP_EXT(ch) (0x05 + ch)
> +#define MAX6639_REG_ALERT_LIMIT(ch) (0x08 + ch)
> +#define MAX6639_REG_OT_LIMIT(ch) (0x0A + ch)
> +#define MAX6639_REG_THERM_LIMIT(ch) (0x0C + ch)
> +#define MAX6639_REG_FAN_CONFIG1(ch) (0x10 + ch * 4)
> +#define MAX6639_REG_FAN_CONFIG2a(ch) (0x11 + ch * 4)
> +#define MAX6639_REG_FAN_CONFIG2b(ch) (0x12 + ch * 4)
> +#define MAX6639_REG_FAN_CONFIG3(ch) (0x13 + ch * 4)
> +#define MAX6639_REG_FAN_CNT(ch) (0x20 + ch)
> +#define MAX6639_REG_TARGET_CNT(ch) (0x22 + ch)
> +#define MAX6639_REG_FAN_PPR(ch) (0x24 + ch)
> +#define MAX6639_REG_TARGTDUTY(ch) (0x26 + ch)
> +#define MAX6639_REG_FAN_START_TEMP(ch) (0x28 + ch)
Usually you would want to have "ch" in (), to ensure it is correct if
"ch" is an expression.
> +#define MAX6639_REG_DEVID 0x3D
> +#define MAX6639_REG_MANUID 0x3E
> +#define MAX6639_REG_DEVREV 0x3F
Not used/needed ?
> +
> +/* Register bits */
> +#define MAX6639_GCONFIG_STANDBY 0x80
> +#define MAX6639_GCONFIG_POR 0x40
> +#define MAX6639_GCONFIG_DISABLE_TIMEOUT 0x20
> +#define MAX6639_GCONFIG_CH2_LOCAL 0x10
> +
> +#define MAX6639_FAN_CONFIG1_PWM 0x80
> +
> +static int rpm_ranges[] = { 2000, 4000, 8000, 16000 };
> +
> +#define FAN_FROM_REG(val, div) ((val) = 0 ? -1 : \
> + (val) = 255 ? 0 : (4000 * 30) / ((div + 1) * (val)))
> +#define TEMP_LIMIT_TO_REG(val) SENSORS_LIMIT((val) / 1000, 0, 255)
> +
> +/*
> + * Client data (each client gets its own)
> + */
> +struct max6639_data {
> + struct device *hwmon_dev;
> + struct mutex update_lock;
> + char valid; /* !=0 if following fields are valid */
> + unsigned long last_updated; /* In jiffies */
> +
> + /* Register values sampled regularly */
> + u16 temp[2]; /* Temperature, in 1/8 C, 0..255 C */
> + u8 fan[2]; /* Register value: TACH count for fans >0 */
> +
> + /* Register values only written to */
> + u8 pwm[2]; /* Register value: Duty cycle 0..120 */
> + u8 temp_therm[2]; /* THERM Temperature, 0..255 C (->_max) */
> + u8 temp_alert[2]; /* ALERT Temperature, 0..255 C (->_crit) */
> + u8 temp_ot[2]; /* OT Temperature, 0..255 C (->_emergency) */
> +
> + /* Register values initialized only once */
> + u8 ppr[2]; /* Pulses per rotation 0..3 for 1..4 ppr */
Don't need ppr[2] - also see below.
> +};
> +
> +static int max6639_read_value(struct i2c_client *client, u8 reg)
> +{
> + return i2c_smbus_read_byte_data(client, reg);
> +}
> +
> +static int max6639_write_value(struct i2c_client *client, u8 reg, u8 value)
> +{
> + return i2c_smbus_write_byte_data(client, reg, value);
> +}
> +
Any reason for not using i2c_smbus_read_byte_data() and
i2c_smbus_write_byte_data() directly ?
> +static struct max6639_data *max6639_update_device(struct device *dev)
> +{
> + struct i2c_client *client = to_i2c_client(dev);
> + struct max6639_data *data = i2c_get_clientdata(client);
> + struct max6639_data *ret = data;
> + int i;
> +
> + mutex_lock(&data->update_lock);
> +
> + if (time_after(jiffies, data->last_updated + 2 * HZ) || !data->valid) {
> + int res;
> +
> + dev_dbg(&client->dev, "Starting max6639 update\n");
> +
> + for (i = 0; i < 2; i++) {
> + res = max6639_read_value(client,
> + MAX6639_REG_FAN_CNT(i));
> + if (res < 0) {
> + ret = ERR_PTR(res);
> + goto abort;
> + }
> + data->fan[i] = res;
> +
> + res = (max6639_read_value(client,
> + MAX6639_REG_TEMP_EXT(i)) >> 5)
> + | (max6639_read_value(client,
> + MAX6639_REG_TEMP(i)) << 3);
You'll have to rewrite that a bit. Logical or and shifting of error
values won't yield a useful result.
> + if (res < 0) {
> + ret = ERR_PTR(res);
> + goto abort;
> + }
> + data->temp[i] = res;
> + }
> +
> + data->last_updated = jiffies;
> + data->valid = 1;
> + }
> +abort:
> + mutex_unlock(&data->update_lock);
> +
> + return ret;
> +}
> +
> +static ssize_t show_temp_input(struct device *dev,
> + struct device_attribute *dev_attr, char *buf)
> +{
> + long temp;
> + struct max6639_data *data = max6639_update_device(dev);
> + struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
> +
Add:
if (IS_ERR(data))
return PTR_ERR(data);
> + temp = data->temp[attr->index] * 125;
> + return sprintf(buf, "%ld\n", temp);
> +}
> +
> +static ssize_t show_temp_max(struct device *dev,
> + struct device_attribute *dev_attr, char *buf)
> +{
> + struct i2c_client *client = to_i2c_client(dev);
> + struct max6639_data *data = i2c_get_clientdata(client);
> + struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
> +
> + return sprintf(buf, "%d\n", (data->temp_therm[attr->index] * 1000));
> +}
> +
> +static ssize_t set_temp_max(struct device *dev,
> + struct device_attribute *dev_attr,
> + const char *buf, size_t count)
> +{
> + struct i2c_client *client = to_i2c_client(dev);
> + struct max6639_data *data = i2c_get_clientdata(client);
> + struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
> + unsigned long val;
> + int res;
> +
> + res = strict_strtoul(buf, 10, &val);
> + if (res)
> + return res;
> +
> + mutex_lock(&data->update_lock);
> + data->temp_therm[attr->index] = TEMP_LIMIT_TO_REG(val);
> + max6639_write_value(client, MAX6639_REG_THERM_LIMIT(attr->index),
> + data->temp_therm[attr->index]);
> + mutex_unlock(&data->update_lock);
> + return count;
> +}
> +
> +static ssize_t show_temp_crit(struct device *dev,
> + struct device_attribute *dev_attr, char *buf)
> +{
> + struct i2c_client *client = to_i2c_client(dev);
> + struct max6639_data *data = i2c_get_clientdata(client);
> + struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
> +
> + return sprintf(buf, "%d\n", (data->temp_alert[attr->index] * 1000));
> +}
> +
> +static ssize_t set_temp_crit(struct device *dev,
> + struct device_attribute *dev_attr,
> + const char *buf, size_t count)
> +{
> + struct i2c_client *client = to_i2c_client(dev);
> + struct max6639_data *data = i2c_get_clientdata(client);
> + struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
> + unsigned long val;
> + int res;
> +
> + res = strict_strtoul(buf, 10, &val);
> + if (res)
> + return res;
> +
> + mutex_lock(&data->update_lock);
> + data->temp_alert[attr->index] = TEMP_LIMIT_TO_REG(val);
> + max6639_write_value(client, MAX6639_REG_THERM_LIMIT(attr->index),
Should be MAX6639_REG_ALERT_LIMIT()
> + data->temp_alert[attr->index]);
> + mutex_unlock(&data->update_lock);
> + return count;
> +}
> +
> +static ssize_t show_temp_emergency(struct device *dev,
> + struct device_attribute *dev_attr,
> + char *buf)
> +{
> + struct i2c_client *client = to_i2c_client(dev);
> + struct max6639_data *data = i2c_get_clientdata(client);
> + struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
> +
> + return sprintf(buf, "%d\n", (data->temp_ot[attr->index] * 1000));
> +}
> +
> +static ssize_t set_temp_emergency(struct device *dev,
> + struct device_attribute *dev_attr,
> + const char *buf, size_t count)
> +{
> + struct i2c_client *client = to_i2c_client(dev);
> + struct max6639_data *data = i2c_get_clientdata(client);
> + struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
> + unsigned long val;
> + int res;
> +
> + res = strict_strtoul(buf, 10, &val);
> + if (res)
> + return res;
> +
> + mutex_lock(&data->update_lock);
> + data->temp_ot[attr->index] = TEMP_LIMIT_TO_REG(val);
> + max6639_write_value(client, MAX6639_REG_THERM_LIMIT(attr->index),
> + data->temp_ot[attr->index]);
Should be MAX6639_REG_OT_LIMIT()
> + mutex_unlock(&data->update_lock);
> + return count;
> +}
> +
> +static ssize_t show_pwm(struct device *dev,
> + struct device_attribute *dev_attr, char *buf)
> +{
> + struct i2c_client *client = to_i2c_client(dev);
> + struct max6639_data *data = i2c_get_clientdata(client);
> + struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
> +
> + return sprintf(buf, "%d\n", data->pwm[attr->index] * 255 / 120);
> +}
> +
> +static ssize_t set_pwm(struct device *dev,
> + struct device_attribute *dev_attr,
> + const char *buf, size_t count)
> +{
> + struct i2c_client *client = to_i2c_client(dev);
> + struct max6639_data *data = i2c_get_clientdata(client);
> + struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
> + long val;
> + int res;
> +
> + res = strict_strtoul(buf, 10, &val);
> + if (res)
> + return res;
> +
> + mutex_lock(&data->update_lock);
> + data->pwm[attr->index] = (u8)(val * 120 / 255);
> + max6639_write_value(client, MAX6639_REG_TARGTDUTY(attr->index),
> + data->pwm[attr->index]);
> + mutex_unlock(&data->update_lock);
> + return count;
> +}
> +
> +static ssize_t show_fan_input(struct device *dev,
> + struct device_attribute *dev_attr, char *buf)
> +{
> + struct max6639_data *data = max6639_update_device(dev);
> + struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
> +
> + return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[attr->index],
> + data->ppr[attr->index]));
> +}
> +
> +static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp_input, NULL, 0);
> +static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp_input, NULL, 1);
> +static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp_max,
> + set_temp_max, 0);
> +static SENSOR_DEVICE_ATTR(temp2_max, S_IWUSR | S_IRUGO, show_temp_max,
> + set_temp_max, 1);
> +static SENSOR_DEVICE_ATTR(temp1_crit, S_IWUSR | S_IRUGO, show_temp_crit,
> + set_temp_crit, 0);
> +static SENSOR_DEVICE_ATTR(temp2_crit, S_IWUSR | S_IRUGO, show_temp_crit,
> + set_temp_crit, 1);
> +static SENSOR_DEVICE_ATTR(temp1_emergency, S_IWUSR | S_IRUGO,
> + show_temp_emergency, set_temp_emergency, 0);
> +static SENSOR_DEVICE_ATTR(temp2_emergency, S_IWUSR | S_IRUGO,
> + show_temp_emergency, set_temp_emergency, 1);
> +static SENSOR_DEVICE_ATTR(pwm1, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 0);
> +static SENSOR_DEVICE_ATTR(pwm2, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 1);
> +static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan_input, NULL, 0);
> +static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, show_fan_input, NULL, 1);
> +
The chip also supports reporting FAULT (extended temp register bit 0).
Please add temp1_fault and temp2_fault to report it.
> +static struct attribute *max6639_attributes[] = {
> + &sensor_dev_attr_temp1_input.dev_attr.attr,
> + &sensor_dev_attr_temp2_input.dev_attr.attr,
> + &sensor_dev_attr_temp1_max.dev_attr.attr,
> + &sensor_dev_attr_temp2_max.dev_attr.attr,
> + &sensor_dev_attr_temp1_crit.dev_attr.attr,
> + &sensor_dev_attr_temp2_crit.dev_attr.attr,
> + &sensor_dev_attr_temp1_emergency.dev_attr.attr,
> + &sensor_dev_attr_temp2_emergency.dev_attr.attr,
> + &sensor_dev_attr_pwm1.dev_attr.attr,
> + &sensor_dev_attr_pwm2.dev_attr.attr,
> + &sensor_dev_attr_fan1_input.dev_attr.attr,
> + &sensor_dev_attr_fan2_input.dev_attr.attr,
> + NULL
> +};
> +
> +static const struct attribute_group max6639_group = {
> + .attrs = max6639_attributes,
> +};
> +
> +/* returns respective index in rpm_ranges table, -1 on invalid range */
> +static int rpm_range_to_reg(int range)
> +{
> + int i;
> + int result = -1;
> +
> + for (i = 0; i < ARRAY_SIZE(rpm_ranges); i++) {
> + if (rpm_ranges[i] = range)
> + result = i;
break; ?
or
return i; ?
> + }
> +
> + return result;
If you return i above, you would not need the result variable and could
simply return -1 here (or 1 as suggested below).
> +}
> +
> +static int max6639_init_client(struct i2c_client *client)
> +{
> + struct max6639_data *data = i2c_get_clientdata(client);
> + struct max6639_platform_data *max6639_info > + client->dev.platform_data;
> + int i;
> + int rpm_range = -1;
> + int err = 0;
> +
> + /* Reset chip to default values */
> + err = max6639_write_value(client, MAX6639_REG_GCONFIG,
> + MAX6639_GCONFIG_POR);
> + if (err)
> + goto exit;
> +
> + /* RPM range, 4000 by default */
> + if (max6639_info)
> + rpm_range = rpm_range_to_reg(max6639_info->rpm_range);
> + if (rpm_range < 0)
> + rpm_range = 1;
> +
If you have rpm_range_to_reg() return 1 if it doesn't find the value,
you could initialize rpm_range with 1 and would not need the additional
error check and update.
> + for (i = 0; i < 2; i++) {
> +
> + /* Fans config PWM, RPM */
> + err = max6639_write_value(client, MAX6639_REG_FAN_CONFIG1(i),
> + MAX6639_FAN_CONFIG1_PWM | rpm_range);
> + if (err)
> + goto exit;
> +
> + /* Fans pulse per revolution is 2 by default */
> + if (max6639_info)
> + data->ppr[i] = max6639_info->ppr;
> + else
> + data->ppr[i] = 2;
Please validate max6639_info->ppr, such as
if (max6639_info && max6639_info->ppr > 0 &&
max6639_info->ppr < 5)
Since ppr is the same for both fans, you don't really need data->ppr[2],
and data->ppr would be sufficient (ie move data->ppr initialization out
of the loop and only initialize the register here).
> + data->ppr[i] -= 1;
> + err = max6639_write_value(client, MAX6639_REG_FAN_PPR(i),
> + (data->ppr[i]) << 5);
> + if (err)
> + goto exit;
> +
> + /* Fans PWM polarity high by default */
> + if (max6639_info && max6639_info->pwm_polarity = 0)
> + err = max6639_write_value(client,
> + MAX6639_REG_FAN_CONFIG2a(i), 0x00);
> + else
> + err = max6639_write_value(client,
> + MAX6639_REG_FAN_CONFIG2a(i), 0x02);
> + if (err)
> + goto exit;
> +
> + /* Max. temp. 80C/90C/100C */
> + data->temp_therm[i] = 80;
> + data->temp_alert[i] = 90;
> + data->temp_ot[i] = 100;
> + err = max6639_write_value(client, MAX6639_REG_THERM_LIMIT(i),
> + data->temp_therm[i]);
> + if (err)
> + goto exit;
> + err = max6639_write_value(client, MAX6639_REG_ALERT_LIMIT(i),
> + data->temp_alert[i]);
> + if (err)
> + goto exit;
> + err = max6639_write_value(client, MAX6639_REG_OT_LIMIT(i),
> + data->temp_ot[i]);
> + if (err)
> + goto exit;
> +
> + /* PWM 120/120 (i.e. 100%) */
> + data->pwm[i] = 120;
> + err = max6639_write_value(client, MAX6639_REG_TARGTDUTY(i),
> + data->pwm[i]);
> + if (err)
> + goto exit;
> + }
> + /* Start monitoring */
> + err = max6639_write_value(client, MAX6639_REG_GCONFIG,
> + MAX6639_GCONFIG_DISABLE_TIMEOUT | MAX6639_GCONFIG_CH2_LOCAL);
> +exit:
> + return err;
> +}
> +
> +/* Return 0 if detection is successful, -ENODEV otherwise */
> +static int max6639_detect(struct i2c_client *client,
> + struct i2c_board_info *info)
> +{
> + struct i2c_adapter *adapter = client->adapter;
> + int dev_id, manu_id;
> +
> + if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
> + return -ENODEV;
> +
> + /* Actual detection via device and manufacturer ID */
> + dev_id = max6639_read_value(client, MAX6639_REG_DEVID);
> + manu_id = max6639_read_value(client, MAX6639_REG_MANUID);
> + if (dev_id != 0x58 || manu_id != 0x4D)
> + return -ENODEV;
> +
> + strlcpy(info->type, "max6639", I2C_NAME_SIZE);
> +
> + return 0;
> +}
> +
> +static int max6639_probe(struct i2c_client *client,
> + const struct i2c_device_id *id)
> +{
> + struct max6639_data *data;
> + int err;
> +
> + data = kzalloc(sizeof(struct max6639_data), GFP_KERNEL);
> + if (!data) {
> + err = -ENOMEM;
> + goto exit;
> + }
> +
> + i2c_set_clientdata(client, data);
> + mutex_init(&data->update_lock);
> +
> + /* Initialize the max6639 chip */
> + err = max6639_init_client(client);
> + if (err < 0)
> + goto error_free;
> +
> + /* Register sysfs hooks */
> + err = sysfs_create_group(&client->dev.kobj, &max6639_group);
> + if (err)
> + goto error_free;
> +
> + data->hwmon_dev = hwmon_device_register(&client->dev);
> + if (IS_ERR(data->hwmon_dev)) {
> + err = PTR_ERR(data->hwmon_dev);
> + goto error_remove;
> + }
> +
> + dev_info(&client->dev, "temperature sensor and fan control found\n");
> +
> + return 0;
> +
> +error_remove:
> + sysfs_remove_group(&client->dev.kobj, &max6639_group);
> +error_free:
> + kfree(data);
> +exit:
> + return err;
> +}
> +
> +static int max6639_remove(struct i2c_client *client)
> +{
> + struct max6639_data *data = i2c_get_clientdata(client);
> +
> + hwmon_device_unregister(data->hwmon_dev);
> + sysfs_remove_group(&client->dev.kobj, &max6639_group);
> +
> + kfree(data);
> + return 0;
> +}
> +
> +static int max6639_suspend(struct i2c_client *client, pm_message_t mesg)
> +{
> + int data = max6639_read_value(client, MAX6639_REG_GCONFIG);
> + if (data < 0)
> + return data;
> +
> + return max6639_write_value(client,
> + MAX6639_REG_GCONFIG, data | MAX6639_GCONFIG_STANDBY);
> +}
> +
> +static int max6639_resume(struct i2c_client *client)
> +{
> + int data = max6639_read_value(client, MAX6639_REG_GCONFIG);
> + if (data < 0)
> + return data;
> +
> + return max6639_write_value(client,
> + MAX6639_REG_GCONFIG, data & ~MAX6639_GCONFIG_STANDBY);
> +}
> +
> +static const struct i2c_device_id max6639_id[] = {
> + {"max6639", 0},
> + {}
> +};
> +
> +MODULE_DEVICE_TABLE(i2c, max6639_id);
> +
> +static struct i2c_driver max6639_driver = {
> + .class = I2C_CLASS_HWMON,
> + .driver = {
> + .name = "max6639",
> + },
> + .probe = max6639_probe,
> + .remove = max6639_remove,
> + .suspend = max6639_suspend,
> + .resume = max6639_resume,
> + .id_table = max6639_id,
> + .detect = max6639_detect,
> + .address_list = normal_i2c,
> +};
> +
> +static int __init max6639_init(void)
> +{
> + return i2c_add_driver(&max6639_driver);
> +}
> +
> +static void __exit max6639_exit(void)
> +{
> + i2c_del_driver(&max6639_driver);
> +}
> +
> +MODULE_AUTHOR("Roland Stigge <stigge@antcom.de>");
> +MODULE_DESCRIPTION("max6639 driver");
> +MODULE_LICENSE("GPL");
> +
> +module_init(max6639_init);
> +module_exit(max6639_exit);
> diff --git a/include/linux/i2c/max6639.h b/include/linux/i2c/max6639.h
> new file mode 100644
> index 0000000..f7323c5
> --- /dev/null
> +++ b/include/linux/i2c/max6639.h
> @@ -0,0 +1,15 @@
> +#ifndef _LINUX_MAX6639_H
> +#define _LINUX_MAX6639_H
> +
> +#include <linux/types.h>
> +#include <linux/i2c.h>
> +
Do you need to include i2c.h here ?
> +/* platform data for the MAX6639 temperature sensor and fan control */
> +
> +struct max6639_platform_data {
> + bool pwm_polarity; /* Polarity low (0) or high (1, default) */
> + int ppr; /* Pulses per rotation 1..4 (default = 1) */
You initialize ppr with 2 above if not configured, so the default is not
correct. Please either change default or initialization code.
> + int rpm_range; /* 2000, 4000 (default), 8000 or 16000 */
> +};
> +
> +#endif /* _LINUX_MAX6639_H */
>
> _______________________________________________
> lm-sensors mailing list
> lm-sensors@lm-sensors.org
> http://lists.lm-sensors.org/mailman/listinfo/lm-sensors
_______________________________________________
lm-sensors mailing list
lm-sensors@lm-sensors.org
http://lists.lm-sensors.org/mailman/listinfo/lm-sensors
^ permalink raw reply [flat|nested] 9+ messages in thread* [lm-sensors] [PATCH] Added driver for Maxim MAX6639
2011-01-18 14:41 [lm-sensors] [PATCH] Added driver for Maxim MAX6639 stigge
` (3 preceding siblings ...)
2011-01-19 18:11 ` Guenter Roeck
@ 2011-01-20 11:00 ` stigge
2011-01-20 11:01 ` Roland Stigge
` (2 subsequent siblings)
7 siblings, 0 replies; 9+ messages in thread
From: stigge @ 2011-01-20 11:00 UTC (permalink / raw)
To: lm-sensors
2-Channel Temperature Monitor with Dual PWM Fan-Speed Controller
Signed-off-by: Roland Stigge <stigge@antcom.de>
diff --git a/Documentation/hwmon/max6639 b/Documentation/hwmon/max6639
new file mode 100644
index 0000000..bd4b08f
--- /dev/null
+++ b/Documentation/hwmon/max6639
@@ -0,0 +1,41 @@
+Kernel driver max6639
+==========+
+Supported chips:
+ * Maxim MAX6639
+ Prefix: 'max6639'
+ Addresses scanned: I2C 0x2c, 0x2e, 0x2f
+ Datasheet: http://pdfserv.maxim-ic.com/en/ds/MAX6639.pdf
+
+Authors:
+ He Changqing <hechangqing@semptian.com>
+ Roland Stigge <stigge@antcom.de>
+
+Description
+-----------
+
+This driver implements support for the Maxim MAX6639. This chip is a 2-channel
+temperature monitor with dual PWM fan speed controller. It can monitor its own
+temperature and one external diode-connected transistor or two external
+diode-connected transistors.
+
+The following device attributes are implemented via sysfs:
+
+Attribute R/W Contents
+----------------------------------------------------------------------------
+temp1_input R Temperature channel 1 input (0..150 C)
+temp2_input R Temperature channel 2 input (0..150 C)
+temp1_fault R Temperature channel 1 diode fault
+temp2_fault R Temperature channel 2 diode fault
+temp1_max RW Set THERM temperature for input 1 (in C, see datasheet)
+temp2_max RW Set THERM temperature for input 2 (in C, see datasheet)
+temp1_crit RW Set ALERM temperature for input 1 (in C, see datasheet)
+temp2_crit RW Set ALARM temperature for input 2 (in C, see datasheet)
+temp1_emergency RW Set OT temperature for input 1 (in C, see datasheet)
+temp2_emergency RW Set OT temperature for input 2 (in C, see datasheet)
+pwm1 RW Fan 1 target duty cycle (0..255)
+pwm2 RW Fan 2 target duty cycle (0..255)
+fan1_input R TACH1 fan tachometer input (in RPM)
+fan2_input R TACH2 fan tachometer input (in RPM)
+fan1_fault R Fan 1 fault
+fan2_fault R Fan 2 fault
diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig
index a56f6ad..8eb116c 100644
--- a/drivers/hwmon/Kconfig
+++ b/drivers/hwmon/Kconfig
@@ -674,6 +674,16 @@ config SENSORS_MAX1619
This driver can also be built as a module. If so, the module
will be called max1619.
+config SENSORS_MAX6639
+ tristate "Maxim MAX6639 sensor chip"
+ depends on I2C && EXPERIMENTAL
+ help
+ If you say yes here you get support for the MAX6639
+ sensor chips.
+
+ This driver can also be built as a module. If so, the module
+ will be called max6639.
+
config SENSORS_MAX6650
tristate "Maxim MAX6650 sensor chip"
depends on I2C && EXPERIMENTAL
diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile
index 2479b3d..a85fa3f 100644
--- a/drivers/hwmon/Makefile
+++ b/drivers/hwmon/Makefile
@@ -83,6 +83,7 @@ obj-$(CONFIG_SENSORS_LTC4245) += ltc4245.o
obj-$(CONFIG_SENSORS_LTC4261) += ltc4261.o
obj-$(CONFIG_SENSORS_MAX1111) += max1111.o
obj-$(CONFIG_SENSORS_MAX1619) += max1619.o
+obj-$(CONFIG_SENSORS_MAX6639) += max6639.o
obj-$(CONFIG_SENSORS_MAX6650) += max6650.o
obj-$(CONFIG_SENSORS_MC13783_ADC)+= mc13783-adc.o
obj-$(CONFIG_SENSORS_PC87360) += pc87360.o
diff --git a/drivers/hwmon/max6639.c b/drivers/hwmon/max6639.c
new file mode 100644
index 0000000..544c053
--- /dev/null
+++ b/drivers/hwmon/max6639.c
@@ -0,0 +1,622 @@
+/*
+ * max6639.c - Support for Maxim MAX6639
+ *
+ * 2-Channel Temperature Monitor with Dual PWM Fan-Speed Controller
+ *
+ * Copyright (C) 2010, 2011 Roland Stigge <stigge@antcom.de>
+ *
+ * based on the initial MAX6639 support from semptian.net
+ * by He Changqing <hechangqing@semptian.com>
+ *
+ * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/jiffies.h>
+#include <linux/i2c.h>
+#include <linux/hwmon.h>
+#include <linux/hwmon-sysfs.h>
+#include <linux/err.h>
+#include <linux/mutex.h>
+#include <linux/i2c/max6639.h>
+
+/* Addresses to scan */
+static unsigned short normal_i2c[] = { 0x2c, 0x2e, 0x2f, I2C_CLIENT_END };
+
+/* The MAX6639 registers, valid channel numbers: 0, 1 */
+#define MAX6639_REG_TEMP(ch) (0x00 + (ch))
+#define MAX6639_REG_STATUS 0x02
+#define MAX6639_REG_OUTPUT_MASK 0x03
+#define MAX6639_REG_GCONFIG 0x04
+#define MAX6639_REG_TEMP_EXT(ch) (0x05 + (ch))
+#define MAX6639_REG_ALERT_LIMIT(ch) (0x08 + (ch))
+#define MAX6639_REG_OT_LIMIT(ch) (0x0A + (ch))
+#define MAX6639_REG_THERM_LIMIT(ch) (0x0C + (ch))
+#define MAX6639_REG_FAN_CONFIG1(ch) (0x10 + (ch) * 4)
+#define MAX6639_REG_FAN_CONFIG2a(ch) (0x11 + (ch) * 4)
+#define MAX6639_REG_FAN_CONFIG2b(ch) (0x12 + (ch) * 4)
+#define MAX6639_REG_FAN_CONFIG3(ch) (0x13 + (ch) * 4)
+#define MAX6639_REG_FAN_CNT(ch) (0x20 + (ch))
+#define MAX6639_REG_TARGET_CNT(ch) (0x22 + (ch))
+#define MAX6639_REG_FAN_PPR(ch) (0x24 + (ch))
+#define MAX6639_REG_TARGTDUTY(ch) (0x26 + (ch))
+#define MAX6639_REG_FAN_START_TEMP(ch) (0x28 + (ch))
+#define MAX6639_REG_DEVID 0x3D
+#define MAX6639_REG_MANUID 0x3E
+#define MAX6639_REG_DEVREV 0x3F
+
+/* Register bits */
+#define MAX6639_GCONFIG_STANDBY 0x80
+#define MAX6639_GCONFIG_POR 0x40
+#define MAX6639_GCONFIG_DISABLE_TIMEOUT 0x20
+#define MAX6639_GCONFIG_CH2_LOCAL 0x10
+
+#define MAX6639_FAN_CONFIG1_PWM 0x80
+
+static int rpm_ranges[] = { 2000, 4000, 8000, 16000 };
+
+#define FAN_FROM_REG(val, div) ((val) = 0 ? -1 : \
+ (val) = 255 ? 0 : (4000 * 30) / ((div + 1) * (val)))
+#define TEMP_LIMIT_TO_REG(val) SENSORS_LIMIT((val) / 1000, 0, 255)
+
+/*
+ * Client data (each client gets its own)
+ */
+struct max6639_data {
+ struct device *hwmon_dev;
+ struct mutex update_lock;
+ char valid; /* !=0 if following fields are valid */
+ unsigned long last_updated; /* In jiffies */
+
+ /* Register values sampled regularly */
+ u16 temp[2]; /* Temperature, in 1/8 C, 0..255 C */
+ bool temp_fault[2]; /* Detected temperature diode failure */
+ u8 fan[2]; /* Register value: TACH count for fans >0 */
+ bool fan_fault[2]; /* Detected fan failure */
+
+ /* Register values only written to */
+ u8 pwm[2]; /* Register value: Duty cycle 0..120 */
+ u8 temp_therm[2]; /* THERM Temperature, 0..255 C (->_max) */
+ u8 temp_alert[2]; /* ALERT Temperature, 0..255 C (->_crit) */
+ u8 temp_ot[2]; /* OT Temperature, 0..255 C (->_emergency) */
+
+ /* Register values initialized only once */
+ u8 ppr; /* Pulses per rotation 0..3 for 1..4 ppr */
+};
+
+static struct max6639_data *max6639_update_device(struct device *dev)
+{
+ struct i2c_client *client = to_i2c_client(dev);
+ struct max6639_data *data = i2c_get_clientdata(client);
+ struct max6639_data *ret = data;
+ int i;
+ int status_reg;
+
+ mutex_lock(&data->update_lock);
+
+ if (time_after(jiffies, data->last_updated + 2 * HZ) || !data->valid) {
+ int res;
+
+ dev_dbg(&client->dev, "Starting max6639 update\n");
+
+ status_reg = i2c_smbus_read_byte_data(client,
+ MAX6639_REG_STATUS);
+ if (status_reg < 0) {
+ ret = ERR_PTR(status_reg);
+ goto abort;
+ }
+
+ for (i = 0; i < 2; i++) {
+ data->fan_fault[i] = (status_reg >> (1 - i)) & 0x01;
+
+ res = i2c_smbus_read_byte_data(client,
+ MAX6639_REG_FAN_CNT(i));
+ if (res < 0) {
+ ret = ERR_PTR(res);
+ goto abort;
+ }
+ data->fan[i] = res;
+
+ res = i2c_smbus_read_byte_data(client,
+ MAX6639_REG_TEMP_EXT(i));
+ if (res < 0) {
+ ret = ERR_PTR(res);
+ goto abort;
+ }
+ data->temp[i] = res >> 5;
+ data->temp_fault[i] = res & 0x01;
+
+ res = i2c_smbus_read_byte_data(client,
+ MAX6639_REG_TEMP(i));
+ if (res < 0) {
+ ret = ERR_PTR(res);
+ goto abort;
+ }
+ data->temp[i] |= res << 3;
+ }
+
+ data->last_updated = jiffies;
+ data->valid = 1;
+ }
+abort:
+ mutex_unlock(&data->update_lock);
+
+ return ret;
+}
+
+static ssize_t show_temp_input(struct device *dev,
+ struct device_attribute *dev_attr, char *buf)
+{
+ long temp;
+ struct max6639_data *data = max6639_update_device(dev);
+ struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
+
+ if (IS_ERR(data))
+ return PTR_ERR(data);
+
+ temp = data->temp[attr->index] * 125;
+ return sprintf(buf, "%ld\n", temp);
+}
+
+static ssize_t show_temp_fault(struct device *dev,
+ struct device_attribute *dev_attr, char *buf)
+{
+ struct max6639_data *data = max6639_update_device(dev);
+ struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
+
+ if (IS_ERR(data))
+ return PTR_ERR(data);
+
+ return sprintf(buf, "%d\n", data->temp_fault[attr->index]);
+}
+
+static ssize_t show_temp_max(struct device *dev,
+ struct device_attribute *dev_attr, char *buf)
+{
+ struct i2c_client *client = to_i2c_client(dev);
+ struct max6639_data *data = i2c_get_clientdata(client);
+ struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
+
+ return sprintf(buf, "%d\n", (data->temp_therm[attr->index] * 1000));
+}
+
+static ssize_t set_temp_max(struct device *dev,
+ struct device_attribute *dev_attr,
+ const char *buf, size_t count)
+{
+ struct i2c_client *client = to_i2c_client(dev);
+ struct max6639_data *data = i2c_get_clientdata(client);
+ struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
+ unsigned long val;
+ int res;
+
+ res = strict_strtoul(buf, 10, &val);
+ if (res)
+ return res;
+
+ mutex_lock(&data->update_lock);
+ data->temp_therm[attr->index] = TEMP_LIMIT_TO_REG(val);
+ i2c_smbus_write_byte_data(client,
+ MAX6639_REG_THERM_LIMIT(attr->index),
+ data->temp_therm[attr->index]);
+ mutex_unlock(&data->update_lock);
+ return count;
+}
+
+static ssize_t show_temp_crit(struct device *dev,
+ struct device_attribute *dev_attr, char *buf)
+{
+ struct i2c_client *client = to_i2c_client(dev);
+ struct max6639_data *data = i2c_get_clientdata(client);
+ struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
+
+ return sprintf(buf, "%d\n", (data->temp_alert[attr->index] * 1000));
+}
+
+static ssize_t set_temp_crit(struct device *dev,
+ struct device_attribute *dev_attr,
+ const char *buf, size_t count)
+{
+ struct i2c_client *client = to_i2c_client(dev);
+ struct max6639_data *data = i2c_get_clientdata(client);
+ struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
+ unsigned long val;
+ int res;
+
+ res = strict_strtoul(buf, 10, &val);
+ if (res)
+ return res;
+
+ mutex_lock(&data->update_lock);
+ data->temp_alert[attr->index] = TEMP_LIMIT_TO_REG(val);
+ i2c_smbus_write_byte_data(client,
+ MAX6639_REG_ALERT_LIMIT(attr->index),
+ data->temp_alert[attr->index]);
+ mutex_unlock(&data->update_lock);
+ return count;
+}
+
+static ssize_t show_temp_emergency(struct device *dev,
+ struct device_attribute *dev_attr,
+ char *buf)
+{
+ struct i2c_client *client = to_i2c_client(dev);
+ struct max6639_data *data = i2c_get_clientdata(client);
+ struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
+
+ return sprintf(buf, "%d\n", (data->temp_ot[attr->index] * 1000));
+}
+
+static ssize_t set_temp_emergency(struct device *dev,
+ struct device_attribute *dev_attr,
+ const char *buf, size_t count)
+{
+ struct i2c_client *client = to_i2c_client(dev);
+ struct max6639_data *data = i2c_get_clientdata(client);
+ struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
+ unsigned long val;
+ int res;
+
+ res = strict_strtoul(buf, 10, &val);
+ if (res)
+ return res;
+
+ mutex_lock(&data->update_lock);
+ data->temp_ot[attr->index] = TEMP_LIMIT_TO_REG(val);
+ i2c_smbus_write_byte_data(client,
+ MAX6639_REG_OT_LIMIT(attr->index),
+ data->temp_ot[attr->index]);
+ mutex_unlock(&data->update_lock);
+ return count;
+}
+
+static ssize_t show_pwm(struct device *dev,
+ struct device_attribute *dev_attr, char *buf)
+{
+ struct i2c_client *client = to_i2c_client(dev);
+ struct max6639_data *data = i2c_get_clientdata(client);
+ struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
+
+ return sprintf(buf, "%d\n", data->pwm[attr->index] * 255 / 120);
+}
+
+static ssize_t set_pwm(struct device *dev,
+ struct device_attribute *dev_attr,
+ const char *buf, size_t count)
+{
+ struct i2c_client *client = to_i2c_client(dev);
+ struct max6639_data *data = i2c_get_clientdata(client);
+ struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
+ long val;
+ int res;
+
+ res = strict_strtoul(buf, 10, &val);
+ if (res)
+ return res;
+
+ mutex_lock(&data->update_lock);
+ data->pwm[attr->index] = (u8)(val * 120 / 255);
+ i2c_smbus_write_byte_data(client,
+ MAX6639_REG_TARGTDUTY(attr->index),
+ data->pwm[attr->index]);
+ mutex_unlock(&data->update_lock);
+ return count;
+}
+
+static ssize_t show_fan_input(struct device *dev,
+ struct device_attribute *dev_attr, char *buf)
+{
+ struct max6639_data *data = max6639_update_device(dev);
+ struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
+
+ if (IS_ERR(data))
+ return PTR_ERR(data);
+
+ return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[attr->index],
+ data->ppr));
+}
+
+static ssize_t show_fan_fault(struct device *dev,
+ struct device_attribute *dev_attr, char *buf)
+{
+ struct max6639_data *data = max6639_update_device(dev);
+ struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
+
+ if (IS_ERR(data))
+ return PTR_ERR(data);
+
+ return sprintf(buf, "%d\n", data->fan_fault[attr->index]);
+}
+
+static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp_input, NULL, 0);
+static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp_input, NULL, 1);
+static SENSOR_DEVICE_ATTR(temp1_fault, S_IRUGO, show_temp_fault, NULL, 0);
+static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_temp_fault, NULL, 1);
+static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp_max,
+ set_temp_max, 0);
+static SENSOR_DEVICE_ATTR(temp2_max, S_IWUSR | S_IRUGO, show_temp_max,
+ set_temp_max, 1);
+static SENSOR_DEVICE_ATTR(temp1_crit, S_IWUSR | S_IRUGO, show_temp_crit,
+ set_temp_crit, 0);
+static SENSOR_DEVICE_ATTR(temp2_crit, S_IWUSR | S_IRUGO, show_temp_crit,
+ set_temp_crit, 1);
+static SENSOR_DEVICE_ATTR(temp1_emergency, S_IWUSR | S_IRUGO,
+ show_temp_emergency, set_temp_emergency, 0);
+static SENSOR_DEVICE_ATTR(temp2_emergency, S_IWUSR | S_IRUGO,
+ show_temp_emergency, set_temp_emergency, 1);
+static SENSOR_DEVICE_ATTR(pwm1, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 0);
+static SENSOR_DEVICE_ATTR(pwm2, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 1);
+static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan_input, NULL, 0);
+static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, show_fan_input, NULL, 1);
+static SENSOR_DEVICE_ATTR(fan1_fault, S_IRUGO, show_fan_fault, NULL, 0);
+static SENSOR_DEVICE_ATTR(fan2_fault, S_IRUGO, show_fan_fault, NULL, 1);
+
+static struct attribute *max6639_attributes[] = {
+ &sensor_dev_attr_temp1_input.dev_attr.attr,
+ &sensor_dev_attr_temp2_input.dev_attr.attr,
+ &sensor_dev_attr_temp1_fault.dev_attr.attr,
+ &sensor_dev_attr_temp2_fault.dev_attr.attr,
+ &sensor_dev_attr_temp1_max.dev_attr.attr,
+ &sensor_dev_attr_temp2_max.dev_attr.attr,
+ &sensor_dev_attr_temp1_crit.dev_attr.attr,
+ &sensor_dev_attr_temp2_crit.dev_attr.attr,
+ &sensor_dev_attr_temp1_emergency.dev_attr.attr,
+ &sensor_dev_attr_temp2_emergency.dev_attr.attr,
+ &sensor_dev_attr_pwm1.dev_attr.attr,
+ &sensor_dev_attr_pwm2.dev_attr.attr,
+ &sensor_dev_attr_fan1_input.dev_attr.attr,
+ &sensor_dev_attr_fan2_input.dev_attr.attr,
+ &sensor_dev_attr_fan1_fault.dev_attr.attr,
+ &sensor_dev_attr_fan2_fault.dev_attr.attr,
+ NULL
+};
+
+static const struct attribute_group max6639_group = {
+ .attrs = max6639_attributes,
+};
+
+/*
+ * returns respective index in rpm_ranges table
+ * 1 by default on invalid range
+ */
+static int rpm_range_to_reg(int range)
+{
+ int i;
+
+ for (i = 0; i < ARRAY_SIZE(rpm_ranges); i++) {
+ if (rpm_ranges[i] = range)
+ return i;
+ }
+
+ return 1; /* default: 4000 RPM */
+}
+
+static int max6639_init_client(struct i2c_client *client)
+{
+ struct max6639_data *data = i2c_get_clientdata(client);
+ struct max6639_platform_data *max6639_info + client->dev.platform_data;
+ int i = 0;
+ int rpm_range = 1; /* default: 4000 RPM */
+ int err = 0;
+
+ /* Reset chip to default values */
+ err = i2c_smbus_write_byte_data(client, MAX6639_REG_GCONFIG,
+ MAX6639_GCONFIG_POR);
+ if (err)
+ goto exit;
+
+ /* Fans pulse per revolution is 2 by default */
+ if (max6639_info && max6639_info->ppr > 0 &&
+ max6639_info->ppr < 5)
+ data->ppr = max6639_info->ppr;
+ else
+ data->ppr = 2;
+ data->ppr -= 1;
+ err = i2c_smbus_write_byte_data(client,
+ MAX6639_REG_FAN_PPR(i),
+ (data->ppr) << 5);
+ if (err)
+ goto exit;
+
+ if (max6639_info)
+ rpm_range = rpm_range_to_reg(max6639_info->rpm_range);
+
+ for (i = 0; i < 2; i++) {
+
+ /* Fans config PWM, RPM */
+ err = i2c_smbus_write_byte_data(client,
+ MAX6639_REG_FAN_CONFIG1(i),
+ MAX6639_FAN_CONFIG1_PWM | rpm_range);
+ if (err)
+ goto exit;
+
+ /* Fans PWM polarity high by default */
+ if (max6639_info && max6639_info->pwm_polarity = 0)
+ err = i2c_smbus_write_byte_data(client,
+ MAX6639_REG_FAN_CONFIG2a(i), 0x00);
+ else
+ err = i2c_smbus_write_byte_data(client,
+ MAX6639_REG_FAN_CONFIG2a(i), 0x02);
+ if (err)
+ goto exit;
+
+ /* Max. temp. 80C/90C/100C */
+ data->temp_therm[i] = 80;
+ data->temp_alert[i] = 90;
+ data->temp_ot[i] = 100;
+ err = i2c_smbus_write_byte_data(client,
+ MAX6639_REG_THERM_LIMIT(i),
+ data->temp_therm[i]);
+ if (err)
+ goto exit;
+ err = i2c_smbus_write_byte_data(client,
+ MAX6639_REG_ALERT_LIMIT(i),
+ data->temp_alert[i]);
+ if (err)
+ goto exit;
+ err = i2c_smbus_write_byte_data(client,
+ MAX6639_REG_OT_LIMIT(i), data->temp_ot[i]);
+ if (err)
+ goto exit;
+
+ /* PWM 120/120 (i.e. 100%) */
+ data->pwm[i] = 120;
+ err = i2c_smbus_write_byte_data(client,
+ MAX6639_REG_TARGTDUTY(i), data->pwm[i]);
+ if (err)
+ goto exit;
+ }
+ /* Start monitoring */
+ err = i2c_smbus_write_byte_data(client, MAX6639_REG_GCONFIG,
+ MAX6639_GCONFIG_DISABLE_TIMEOUT | MAX6639_GCONFIG_CH2_LOCAL);
+exit:
+ return err;
+}
+
+/* Return 0 if detection is successful, -ENODEV otherwise */
+static int max6639_detect(struct i2c_client *client,
+ struct i2c_board_info *info)
+{
+ struct i2c_adapter *adapter = client->adapter;
+ int dev_id, manu_id;
+
+ if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
+ return -ENODEV;
+
+ /* Actual detection via device and manufacturer ID */
+ dev_id = i2c_smbus_read_byte_data(client, MAX6639_REG_DEVID);
+ manu_id = i2c_smbus_read_byte_data(client, MAX6639_REG_MANUID);
+ if (dev_id != 0x58 || manu_id != 0x4D)
+ return -ENODEV;
+
+ strlcpy(info->type, "max6639", I2C_NAME_SIZE);
+
+ return 0;
+}
+
+static int max6639_probe(struct i2c_client *client,
+ const struct i2c_device_id *id)
+{
+ struct max6639_data *data;
+ int err;
+
+ data = kzalloc(sizeof(struct max6639_data), GFP_KERNEL);
+ if (!data) {
+ err = -ENOMEM;
+ goto exit;
+ }
+
+ i2c_set_clientdata(client, data);
+ mutex_init(&data->update_lock);
+
+ /* Initialize the max6639 chip */
+ err = max6639_init_client(client);
+ if (err < 0)
+ goto error_free;
+
+ /* Register sysfs hooks */
+ err = sysfs_create_group(&client->dev.kobj, &max6639_group);
+ if (err)
+ goto error_free;
+
+ data->hwmon_dev = hwmon_device_register(&client->dev);
+ if (IS_ERR(data->hwmon_dev)) {
+ err = PTR_ERR(data->hwmon_dev);
+ goto error_remove;
+ }
+
+ dev_info(&client->dev, "temperature sensor and fan control found\n");
+
+ return 0;
+
+error_remove:
+ sysfs_remove_group(&client->dev.kobj, &max6639_group);
+error_free:
+ kfree(data);
+exit:
+ return err;
+}
+
+static int max6639_remove(struct i2c_client *client)
+{
+ struct max6639_data *data = i2c_get_clientdata(client);
+
+ hwmon_device_unregister(data->hwmon_dev);
+ sysfs_remove_group(&client->dev.kobj, &max6639_group);
+
+ kfree(data);
+ return 0;
+}
+
+static int max6639_suspend(struct i2c_client *client, pm_message_t mesg)
+{
+ int data = i2c_smbus_read_byte_data(client, MAX6639_REG_GCONFIG);
+ if (data < 0)
+ return data;
+
+ return i2c_smbus_write_byte_data(client,
+ MAX6639_REG_GCONFIG, data | MAX6639_GCONFIG_STANDBY);
+}
+
+static int max6639_resume(struct i2c_client *client)
+{
+ int data = i2c_smbus_read_byte_data(client, MAX6639_REG_GCONFIG);
+ if (data < 0)
+ return data;
+
+ return i2c_smbus_write_byte_data(client,
+ MAX6639_REG_GCONFIG, data & ~MAX6639_GCONFIG_STANDBY);
+}
+
+static const struct i2c_device_id max6639_id[] = {
+ {"max6639", 0},
+ {}
+};
+
+MODULE_DEVICE_TABLE(i2c, max6639_id);
+
+static struct i2c_driver max6639_driver = {
+ .class = I2C_CLASS_HWMON,
+ .driver = {
+ .name = "max6639",
+ },
+ .probe = max6639_probe,
+ .remove = max6639_remove,
+ .suspend = max6639_suspend,
+ .resume = max6639_resume,
+ .id_table = max6639_id,
+ .detect = max6639_detect,
+ .address_list = normal_i2c,
+};
+
+static int __init max6639_init(void)
+{
+ return i2c_add_driver(&max6639_driver);
+}
+
+static void __exit max6639_exit(void)
+{
+ i2c_del_driver(&max6639_driver);
+}
+
+MODULE_AUTHOR("Roland Stigge <stigge@antcom.de>");
+MODULE_DESCRIPTION("max6639 driver");
+MODULE_LICENSE("GPL");
+
+module_init(max6639_init);
+module_exit(max6639_exit);
diff --git a/include/linux/i2c/max6639.h b/include/linux/i2c/max6639.h
new file mode 100644
index 0000000..6011c42
--- /dev/null
+++ b/include/linux/i2c/max6639.h
@@ -0,0 +1,14 @@
+#ifndef _LINUX_MAX6639_H
+#define _LINUX_MAX6639_H
+
+#include <linux/types.h>
+
+/* platform data for the MAX6639 temperature sensor and fan control */
+
+struct max6639_platform_data {
+ bool pwm_polarity; /* Polarity low (0) or high (1, default) */
+ int ppr; /* Pulses per rotation 1..4 (default = 2) */
+ int rpm_range; /* 2000, 4000 (default), 8000 or 16000 */
+};
+
+#endif /* _LINUX_MAX6639_H */
_______________________________________________
lm-sensors mailing list
lm-sensors@lm-sensors.org
http://lists.lm-sensors.org/mailman/listinfo/lm-sensors
^ permalink raw reply related [flat|nested] 9+ messages in thread* Re: [lm-sensors] [PATCH] Added driver for Maxim MAX6639
2011-01-18 14:41 [lm-sensors] [PATCH] Added driver for Maxim MAX6639 stigge
` (4 preceding siblings ...)
2011-01-20 11:00 ` stigge
@ 2011-01-20 11:01 ` Roland Stigge
2011-01-20 15:57 ` Guenter Roeck
2011-01-20 17:43 ` Roland Stigge
7 siblings, 0 replies; 9+ messages in thread
From: Roland Stigge @ 2011-01-20 11:01 UTC (permalink / raw)
To: lm-sensors
Hi Guenter,
thanks again for your helpful suggestions!
I considered them in the new version (see other mail).
On 01/19/2011 07:11 PM, Guenter Roeck wrote:
>> +#define MAX6639_REG_DEVID 0x3D
>> +#define MAX6639_REG_MANUID 0x3E
>> +#define MAX6639_REG_DEVREV 0x3F
>
> Not used/needed ?
Not used currently. I would prefer keeping it for future use and
documentation in-source of the chip. This way, we have the complete
register set listed. Just tell me if we need to remove it for policy
reasons etc.
Thanks,
Roland
--
Dipl.-Inf. Roland Stigge
SATCOM Technologies
**********************************************************
WORK Microwave GmbH
Raiffeisenstrasse 12
83607 Holzkirchen
Germany
Tel: +49 8024 6408-0
Fax: +49 8024 6408-40
roland.stigge@work-microwave.de
http://www.work-microwave.de./
Gesch채ftsf체hrer / Managing Directors:
Dr. Andreas Hausotter (CEO), Dr. G체nter Prokoph (CTO)
Sitz / Reg. Office: Holzkirchen, Germany
Reg. HRB M체nchen Nr. 79479
ISO 9001:2008 certificate
This message and any attachments may contain confidential information
and must not be disclosed to a third party without the prior written
consent of Work Microwave GmbH, Germany.
If you have received it erroneously, please discard it and contact us by
return.
**********************************************************
_______________________________________________
lm-sensors mailing list
lm-sensors@lm-sensors.org
http://lists.lm-sensors.org/mailman/listinfo/lm-sensors
^ permalink raw reply [flat|nested] 9+ messages in thread* Re: [lm-sensors] [PATCH] Added driver for Maxim MAX6639
2011-01-18 14:41 [lm-sensors] [PATCH] Added driver for Maxim MAX6639 stigge
` (5 preceding siblings ...)
2011-01-20 11:01 ` Roland Stigge
@ 2011-01-20 15:57 ` Guenter Roeck
2011-01-20 17:43 ` Roland Stigge
7 siblings, 0 replies; 9+ messages in thread
From: Guenter Roeck @ 2011-01-20 15:57 UTC (permalink / raw)
To: lm-sensors
On Thu, Jan 20, 2011 at 06:00:54AM -0500, stigge@antcom.de wrote:
> 2-Channel Temperature Monitor with Dual PWM Fan-Speed Controller
>
> Signed-off-by: Roland Stigge <stigge@antcom.de>
>
Hopefully the last round this time.
On a side note, would be nice if you could provide the patch version and
a list of changes made in resubmits.
> diff --git a/Documentation/hwmon/max6639 b/Documentation/hwmon/max6639
> new file mode 100644
> index 0000000..bd4b08f
> --- /dev/null
> +++ b/Documentation/hwmon/max6639
> @@ -0,0 +1,41 @@
> +Kernel driver max6639
> +==========> +
> +Supported chips:
> + * Maxim MAX6639
> + Prefix: 'max6639'
> + Addresses scanned: I2C 0x2c, 0x2e, 0x2f
> + Datasheet: http://pdfserv.maxim-ic.com/en/ds/MAX6639.pdf
> +
> +Authors:
> + He Changqing <hechangqing@semptian.com>
> + Roland Stigge <stigge@antcom.de>
> +
> +Description
> +-----------
> +
> +This driver implements support for the Maxim MAX6639. This chip is a 2-channel
> +temperature monitor with dual PWM fan speed controller. It can monitor its own
> +temperature and one external diode-connected transistor or two external
> +diode-connected transistors.
> +
> +The following device attributes are implemented via sysfs:
> +
> +Attribute R/W Contents
> +----------------------------------------------------------------------------
> +temp1_input R Temperature channel 1 input (0..150 C)
> +temp2_input R Temperature channel 2 input (0..150 C)
> +temp1_fault R Temperature channel 1 diode fault
> +temp2_fault R Temperature channel 2 diode fault
> +temp1_max RW Set THERM temperature for input 1 (in C, see datasheet)
> +temp2_max RW Set THERM temperature for input 2 (in C, see datasheet)
> +temp1_crit RW Set ALERM temperature for input 1 (in C, see datasheet)
> +temp2_crit RW Set ALARM temperature for input 2 (in C, see datasheet)
> +temp1_emergency RW Set OT temperature for input 1 (in C, see datasheet)
> +temp2_emergency RW Set OT temperature for input 2 (in C, see datasheet)
> +pwm1 RW Fan 1 target duty cycle (0..255)
> +pwm2 RW Fan 2 target duty cycle (0..255)
> +fan1_input R TACH1 fan tachometer input (in RPM)
> +fan2_input R TACH2 fan tachometer input (in RPM)
> +fan1_fault R Fan 1 fault
> +fan2_fault R Fan 2 fault
> diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig
> index a56f6ad..8eb116c 100644
> --- a/drivers/hwmon/Kconfig
> +++ b/drivers/hwmon/Kconfig
> @@ -674,6 +674,16 @@ config SENSORS_MAX1619
> This driver can also be built as a module. If so, the module
> will be called max1619.
>
> +config SENSORS_MAX6639
> + tristate "Maxim MAX6639 sensor chip"
> + depends on I2C && EXPERIMENTAL
> + help
> + If you say yes here you get support for the MAX6639
> + sensor chips.
> +
> + This driver can also be built as a module. If so, the module
> + will be called max6639.
> +
> config SENSORS_MAX6650
> tristate "Maxim MAX6650 sensor chip"
> depends on I2C && EXPERIMENTAL
> diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile
> index 2479b3d..a85fa3f 100644
> --- a/drivers/hwmon/Makefile
> +++ b/drivers/hwmon/Makefile
> @@ -83,6 +83,7 @@ obj-$(CONFIG_SENSORS_LTC4245) += ltc4245.o
> obj-$(CONFIG_SENSORS_LTC4261) += ltc4261.o
> obj-$(CONFIG_SENSORS_MAX1111) += max1111.o
> obj-$(CONFIG_SENSORS_MAX1619) += max1619.o
> +obj-$(CONFIG_SENSORS_MAX6639) += max6639.o
> obj-$(CONFIG_SENSORS_MAX6650) += max6650.o
> obj-$(CONFIG_SENSORS_MC13783_ADC)+= mc13783-adc.o
> obj-$(CONFIG_SENSORS_PC87360) += pc87360.o
> diff --git a/drivers/hwmon/max6639.c b/drivers/hwmon/max6639.c
> new file mode 100644
> index 0000000..544c053
> --- /dev/null
> +++ b/drivers/hwmon/max6639.c
> @@ -0,0 +1,622 @@
> +/*
> + * max6639.c - Support for Maxim MAX6639
> + *
> + * 2-Channel Temperature Monitor with Dual PWM Fan-Speed Controller
> + *
> + * Copyright (C) 2010, 2011 Roland Stigge <stigge@antcom.de>
> + *
> + * based on the initial MAX6639 support from semptian.net
> + * by He Changqing <hechangqing@semptian.com>
> + *
> + * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
> + */
> +
> +#include <linux/module.h>
> +#include <linux/init.h>
> +#include <linux/slab.h>
> +#include <linux/jiffies.h>
> +#include <linux/i2c.h>
> +#include <linux/hwmon.h>
> +#include <linux/hwmon-sysfs.h>
> +#include <linux/err.h>
> +#include <linux/mutex.h>
> +#include <linux/i2c/max6639.h>
> +
> +/* Addresses to scan */
> +static unsigned short normal_i2c[] = { 0x2c, 0x2e, 0x2f, I2C_CLIENT_END };
> +
> +/* The MAX6639 registers, valid channel numbers: 0, 1 */
> +#define MAX6639_REG_TEMP(ch) (0x00 + (ch))
> +#define MAX6639_REG_STATUS 0x02
> +#define MAX6639_REG_OUTPUT_MASK 0x03
> +#define MAX6639_REG_GCONFIG 0x04
> +#define MAX6639_REG_TEMP_EXT(ch) (0x05 + (ch))
> +#define MAX6639_REG_ALERT_LIMIT(ch) (0x08 + (ch))
> +#define MAX6639_REG_OT_LIMIT(ch) (0x0A + (ch))
> +#define MAX6639_REG_THERM_LIMIT(ch) (0x0C + (ch))
> +#define MAX6639_REG_FAN_CONFIG1(ch) (0x10 + (ch) * 4)
> +#define MAX6639_REG_FAN_CONFIG2a(ch) (0x11 + (ch) * 4)
> +#define MAX6639_REG_FAN_CONFIG2b(ch) (0x12 + (ch) * 4)
> +#define MAX6639_REG_FAN_CONFIG3(ch) (0x13 + (ch) * 4)
> +#define MAX6639_REG_FAN_CNT(ch) (0x20 + (ch))
> +#define MAX6639_REG_TARGET_CNT(ch) (0x22 + (ch))
> +#define MAX6639_REG_FAN_PPR(ch) (0x24 + (ch))
> +#define MAX6639_REG_TARGTDUTY(ch) (0x26 + (ch))
> +#define MAX6639_REG_FAN_START_TEMP(ch) (0x28 + (ch))
> +#define MAX6639_REG_DEVID 0x3D
> +#define MAX6639_REG_MANUID 0x3E
> +#define MAX6639_REG_DEVREV 0x3F
> +
> +/* Register bits */
> +#define MAX6639_GCONFIG_STANDBY 0x80
> +#define MAX6639_GCONFIG_POR 0x40
> +#define MAX6639_GCONFIG_DISABLE_TIMEOUT 0x20
> +#define MAX6639_GCONFIG_CH2_LOCAL 0x10
> +
> +#define MAX6639_FAN_CONFIG1_PWM 0x80
> +
> +static int rpm_ranges[] = { 2000, 4000, 8000, 16000 };
> +
const int
> +#define FAN_FROM_REG(val, div) ((val) = 0 ? -1 : \
> + (val) = 255 ? 0 : (4000 * 30) / ((div + 1) * (val)))
Can you have another look into this macro ? I suspect the 4000 reflects
the maximum RPM, which is now configurable.
> +#define TEMP_LIMIT_TO_REG(val) SENSORS_LIMIT((val) / 1000, 0, 255)
> +
> +/*
> + * Client data (each client gets its own)
> + */
> +struct max6639_data {
> + struct device *hwmon_dev;
> + struct mutex update_lock;
> + char valid; /* !=0 if following fields are valid */
> + unsigned long last_updated; /* In jiffies */
> +
> + /* Register values sampled regularly */
> + u16 temp[2]; /* Temperature, in 1/8 C, 0..255 C */
> + bool temp_fault[2]; /* Detected temperature diode failure */
> + u8 fan[2]; /* Register value: TACH count for fans >0 */
> + bool fan_fault[2]; /* Detected fan failure */
> +
After seeing that, noticed that the chip also supports alarm bits for all sensors
in the status register.
If you don't mind, would be great if you could add support for those as well. Best
would probably be to just store the status register as-is and check for the bit
in the show function. Good part is that you'll only need a single show function
sfor all six attributes. See further below for details.
> + /* Register values only written to */
> + u8 pwm[2]; /* Register value: Duty cycle 0..120 */
> + u8 temp_therm[2]; /* THERM Temperature, 0..255 C (->_max) */
> + u8 temp_alert[2]; /* ALERT Temperature, 0..255 C (->_crit) */
> + u8 temp_ot[2]; /* OT Temperature, 0..255 C (->_emergency) */
> +
> + /* Register values initialized only once */
> + u8 ppr; /* Pulses per rotation 0..3 for 1..4 ppr */
> +};
> +
> +static struct max6639_data *max6639_update_device(struct device *dev)
> +{
> + struct i2c_client *client = to_i2c_client(dev);
> + struct max6639_data *data = i2c_get_clientdata(client);
> + struct max6639_data *ret = data;
> + int i;
> + int status_reg;
> +
> + mutex_lock(&data->update_lock);
> +
> + if (time_after(jiffies, data->last_updated + 2 * HZ) || !data->valid) {
> + int res;
> +
> + dev_dbg(&client->dev, "Starting max6639 update\n");
> +
> + status_reg = i2c_smbus_read_byte_data(client,
> + MAX6639_REG_STATUS);
> + if (status_reg < 0) {
> + ret = ERR_PTR(status_reg);
> + goto abort;
> + }
> +
> + for (i = 0; i < 2; i++) {
> + data->fan_fault[i] = (status_reg >> (1 - i)) & 0x01;
> +
> + res = i2c_smbus_read_byte_data(client,
> + MAX6639_REG_FAN_CNT(i));
> + if (res < 0) {
> + ret = ERR_PTR(res);
> + goto abort;
> + }
> + data->fan[i] = res;
> +
> + res = i2c_smbus_read_byte_data(client,
> + MAX6639_REG_TEMP_EXT(i));
> + if (res < 0) {
> + ret = ERR_PTR(res);
> + goto abort;
> + }
> + data->temp[i] = res >> 5;
> + data->temp_fault[i] = res & 0x01;
> +
> + res = i2c_smbus_read_byte_data(client,
> + MAX6639_REG_TEMP(i));
> + if (res < 0) {
> + ret = ERR_PTR(res);
> + goto abort;
> + }
> + data->temp[i] |= res << 3;
> + }
> +
> + data->last_updated = jiffies;
> + data->valid = 1;
> + }
> +abort:
> + mutex_unlock(&data->update_lock);
> +
> + return ret;
> +}
> +
> +static ssize_t show_temp_input(struct device *dev,
> + struct device_attribute *dev_attr, char *buf)
> +{
> + long temp;
> + struct max6639_data *data = max6639_update_device(dev);
> + struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
> +
> + if (IS_ERR(data))
> + return PTR_ERR(data);
> +
> + temp = data->temp[attr->index] * 125;
> + return sprintf(buf, "%ld\n", temp);
> +}
> +
> +static ssize_t show_temp_fault(struct device *dev,
> + struct device_attribute *dev_attr, char *buf)
> +{
> + struct max6639_data *data = max6639_update_device(dev);
> + struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
> +
> + if (IS_ERR(data))
> + return PTR_ERR(data);
> +
> + return sprintf(buf, "%d\n", data->temp_fault[attr->index]);
> +}
> +
> +static ssize_t show_temp_max(struct device *dev,
> + struct device_attribute *dev_attr, char *buf)
> +{
> + struct i2c_client *client = to_i2c_client(dev);
> + struct max6639_data *data = i2c_get_clientdata(client);
> + struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
> +
> + return sprintf(buf, "%d\n", (data->temp_therm[attr->index] * 1000));
> +}
> +
> +static ssize_t set_temp_max(struct device *dev,
> + struct device_attribute *dev_attr,
> + const char *buf, size_t count)
> +{
> + struct i2c_client *client = to_i2c_client(dev);
> + struct max6639_data *data = i2c_get_clientdata(client);
> + struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
> + unsigned long val;
> + int res;
> +
> + res = strict_strtoul(buf, 10, &val);
> + if (res)
> + return res;
> +
> + mutex_lock(&data->update_lock);
> + data->temp_therm[attr->index] = TEMP_LIMIT_TO_REG(val);
> + i2c_smbus_write_byte_data(client,
> + MAX6639_REG_THERM_LIMIT(attr->index),
> + data->temp_therm[attr->index]);
> + mutex_unlock(&data->update_lock);
> + return count;
> +}
> +
> +static ssize_t show_temp_crit(struct device *dev,
> + struct device_attribute *dev_attr, char *buf)
> +{
> + struct i2c_client *client = to_i2c_client(dev);
> + struct max6639_data *data = i2c_get_clientdata(client);
> + struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
> +
> + return sprintf(buf, "%d\n", (data->temp_alert[attr->index] * 1000));
> +}
> +
> +static ssize_t set_temp_crit(struct device *dev,
> + struct device_attribute *dev_attr,
> + const char *buf, size_t count)
> +{
> + struct i2c_client *client = to_i2c_client(dev);
> + struct max6639_data *data = i2c_get_clientdata(client);
> + struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
> + unsigned long val;
> + int res;
> +
> + res = strict_strtoul(buf, 10, &val);
> + if (res)
> + return res;
> +
> + mutex_lock(&data->update_lock);
> + data->temp_alert[attr->index] = TEMP_LIMIT_TO_REG(val);
> + i2c_smbus_write_byte_data(client,
> + MAX6639_REG_ALERT_LIMIT(attr->index),
> + data->temp_alert[attr->index]);
> + mutex_unlock(&data->update_lock);
> + return count;
> +}
> +
> +static ssize_t show_temp_emergency(struct device *dev,
> + struct device_attribute *dev_attr,
> + char *buf)
> +{
> + struct i2c_client *client = to_i2c_client(dev);
> + struct max6639_data *data = i2c_get_clientdata(client);
> + struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
> +
> + return sprintf(buf, "%d\n", (data->temp_ot[attr->index] * 1000));
> +}
> +
> +static ssize_t set_temp_emergency(struct device *dev,
> + struct device_attribute *dev_attr,
> + const char *buf, size_t count)
> +{
> + struct i2c_client *client = to_i2c_client(dev);
> + struct max6639_data *data = i2c_get_clientdata(client);
> + struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
> + unsigned long val;
> + int res;
> +
> + res = strict_strtoul(buf, 10, &val);
> + if (res)
> + return res;
> +
> + mutex_lock(&data->update_lock);
> + data->temp_ot[attr->index] = TEMP_LIMIT_TO_REG(val);
> + i2c_smbus_write_byte_data(client,
> + MAX6639_REG_OT_LIMIT(attr->index),
> + data->temp_ot[attr->index]);
> + mutex_unlock(&data->update_lock);
> + return count;
> +}
> +
> +static ssize_t show_pwm(struct device *dev,
> + struct device_attribute *dev_attr, char *buf)
> +{
> + struct i2c_client *client = to_i2c_client(dev);
> + struct max6639_data *data = i2c_get_clientdata(client);
> + struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
> +
> + return sprintf(buf, "%d\n", data->pwm[attr->index] * 255 / 120);
> +}
> +
> +static ssize_t set_pwm(struct device *dev,
> + struct device_attribute *dev_attr,
> + const char *buf, size_t count)
> +{
> + struct i2c_client *client = to_i2c_client(dev);
> + struct max6639_data *data = i2c_get_clientdata(client);
> + struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
> + long val;
> + int res;
> +
> + res = strict_strtoul(buf, 10, &val);
> + if (res)
> + return res;
> +
Please add range validation.
Might either use SENSORS_LIMIT or return an error if the value is larger than 255.
> + mutex_lock(&data->update_lock);
> + data->pwm[attr->index] = (u8)(val * 120 / 255);
> + i2c_smbus_write_byte_data(client,
> + MAX6639_REG_TARGTDUTY(attr->index),
> + data->pwm[attr->index]);
> + mutex_unlock(&data->update_lock);
> + return count;
> +}
> +
> +static ssize_t show_fan_input(struct device *dev,
> + struct device_attribute *dev_attr, char *buf)
> +{
> + struct max6639_data *data = max6639_update_device(dev);
> + struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
> +
> + if (IS_ERR(data))
> + return PTR_ERR(data);
> +
> + return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[attr->index],
> + data->ppr));
> +}
> +
> +static ssize_t show_fan_fault(struct device *dev,
> + struct device_attribute *dev_attr, char *buf)
> +{
> + struct max6639_data *data = max6639_update_device(dev);
> + struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
> +
> + if (IS_ERR(data))
> + return PTR_ERR(data);
> +
> + return sprintf(buf, "%d\n", data->fan_fault[attr->index]);
> +}
Generic show function for all alarms and faults reported in the status register:
static ssize_t show_alarm(struct device *dev,
struct device_attribute *dev_attr, char *buf)
{
struct max6639_data *data = max6639_update_device(dev);
struct sensor_device_attribute *attr = to_sensor_dev_attr(dev_attr);
if (IS_ERR(data))
return PTR_ERR(data);
return sprintf(buf, "%d\n", !!(data->status & (1 << attr->index)));
}
> +static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp_input, NULL, 0);
> +static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp_input, NULL, 1);
> +static SENSOR_DEVICE_ATTR(temp1_fault, S_IRUGO, show_temp_fault, NULL, 0);
> +static SENSOR_DEVICE_ATTR(temp2_fault, S_IRUGO, show_temp_fault, NULL, 1);
> +static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp_max,
> + set_temp_max, 0);
> +static SENSOR_DEVICE_ATTR(temp2_max, S_IWUSR | S_IRUGO, show_temp_max,
> + set_temp_max, 1);
> +static SENSOR_DEVICE_ATTR(temp1_crit, S_IWUSR | S_IRUGO, show_temp_crit,
> + set_temp_crit, 0);
> +static SENSOR_DEVICE_ATTR(temp2_crit, S_IWUSR | S_IRUGO, show_temp_crit,
> + set_temp_crit, 1);
> +static SENSOR_DEVICE_ATTR(temp1_emergency, S_IWUSR | S_IRUGO,
> + show_temp_emergency, set_temp_emergency, 0);
> +static SENSOR_DEVICE_ATTR(temp2_emergency, S_IWUSR | S_IRUGO,
> + show_temp_emergency, set_temp_emergency, 1);
> +static SENSOR_DEVICE_ATTR(pwm1, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 0);
> +static SENSOR_DEVICE_ATTR(pwm2, S_IWUSR | S_IRUGO, show_pwm, set_pwm, 1);
> +static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan_input, NULL, 0);
> +static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, show_fan_input, NULL, 1);
> +static SENSOR_DEVICE_ATTR(fan1_fault, S_IRUGO, show_fan_fault, NULL, 0);
> +static SENSOR_DEVICE_ATTR(fan2_fault, S_IRUGO, show_fan_fault, NULL, 1);
Using the generic function above:
static SENSOR_DEVICE_ATTR(fan1_fault, S_IRUGO, show_alarm, NULL, 1);
static SENSOR_DEVICE_ATTR(fan2_fault, S_IRUGO, show_alarm, NULL, 0);
static SENSOR_DEVICE_ATTR(temp1_max_alarm, S_IRUGO, show_alarm, NULL, 3);
static SENSOR_DEVICE_ATTR(temp2_max_alarm, S_IRUGO, show_alarm, NULL, 2);
static SENSOR_DEVICE_ATTR(temp1_crit_alarm, S_IRUGO, show_alarm, NULL, 6);
static SENSOR_DEVICE_ATTR(temp2_crit_alarm, S_IRUGO, show_alarm, NULL, 5);
static SENSOR_DEVICE_ATTR(temp1_emergency_alarm, S_IRUGO, show_alarm, NULL, 4);
static SENSOR_DEVICE_ATTR(temp2_emergency_alarm, S_IRUGO, show_alarm, NULL, 3);
> +
> +static struct attribute *max6639_attributes[] = {
> + &sensor_dev_attr_temp1_input.dev_attr.attr,
> + &sensor_dev_attr_temp2_input.dev_attr.attr,
> + &sensor_dev_attr_temp1_fault.dev_attr.attr,
> + &sensor_dev_attr_temp2_fault.dev_attr.attr,
> + &sensor_dev_attr_temp1_max.dev_attr.attr,
> + &sensor_dev_attr_temp2_max.dev_attr.attr,
> + &sensor_dev_attr_temp1_crit.dev_attr.attr,
> + &sensor_dev_attr_temp2_crit.dev_attr.attr,
> + &sensor_dev_attr_temp1_emergency.dev_attr.attr,
> + &sensor_dev_attr_temp2_emergency.dev_attr.attr,
> + &sensor_dev_attr_pwm1.dev_attr.attr,
> + &sensor_dev_attr_pwm2.dev_attr.attr,
> + &sensor_dev_attr_fan1_input.dev_attr.attr,
> + &sensor_dev_attr_fan2_input.dev_attr.attr,
> + &sensor_dev_attr_fan1_fault.dev_attr.attr,
> + &sensor_dev_attr_fan2_fault.dev_attr.attr,
> + NULL
> +};
> +
> +static const struct attribute_group max6639_group = {
> + .attrs = max6639_attributes,
> +};
> +
> +/*
> + * returns respective index in rpm_ranges table
> + * 1 by default on invalid range
> + */
> +static int rpm_range_to_reg(int range)
> +{
> + int i;
> +
> + for (i = 0; i < ARRAY_SIZE(rpm_ranges); i++) {
> + if (rpm_ranges[i] = range)
> + return i;
> + }
> +
> + return 1; /* default: 4000 RPM */
> +}
> +
> +static int max6639_init_client(struct i2c_client *client)
> +{
> + struct max6639_data *data = i2c_get_clientdata(client);
> + struct max6639_platform_data *max6639_info > + client->dev.platform_data;
> + int i = 0;
> + int rpm_range = 1; /* default: 4000 RPM */
> + int err = 0;
> +
> + /* Reset chip to default values */
> + err = i2c_smbus_write_byte_data(client, MAX6639_REG_GCONFIG,
> + MAX6639_GCONFIG_POR);
> + if (err)
> + goto exit;
> +
> + /* Fans pulse per revolution is 2 by default */
> + if (max6639_info && max6639_info->ppr > 0 &&
> + max6639_info->ppr < 5)
> + data->ppr = max6639_info->ppr;
> + else
> + data->ppr = 2;
> + data->ppr -= 1;
> + err = i2c_smbus_write_byte_data(client,
> + MAX6639_REG_FAN_PPR(i),
> + (data->ppr) << 5);
> + if (err)
> + goto exit;
> +
> + if (max6639_info)
> + rpm_range = rpm_range_to_reg(max6639_info->rpm_range);
> +
> + for (i = 0; i < 2; i++) {
> +
> + /* Fans config PWM, RPM */
> + err = i2c_smbus_write_byte_data(client,
> + MAX6639_REG_FAN_CONFIG1(i),
> + MAX6639_FAN_CONFIG1_PWM | rpm_range);
> + if (err)
> + goto exit;
> +
> + /* Fans PWM polarity high by default */
> + if (max6639_info && max6639_info->pwm_polarity = 0)
> + err = i2c_smbus_write_byte_data(client,
> + MAX6639_REG_FAN_CONFIG2a(i), 0x00);
> + else
> + err = i2c_smbus_write_byte_data(client,
> + MAX6639_REG_FAN_CONFIG2a(i), 0x02);
> + if (err)
> + goto exit;
> +
> + /* Max. temp. 80C/90C/100C */
> + data->temp_therm[i] = 80;
> + data->temp_alert[i] = 90;
> + data->temp_ot[i] = 100;
> + err = i2c_smbus_write_byte_data(client,
> + MAX6639_REG_THERM_LIMIT(i),
> + data->temp_therm[i]);
> + if (err)
> + goto exit;
> + err = i2c_smbus_write_byte_data(client,
> + MAX6639_REG_ALERT_LIMIT(i),
> + data->temp_alert[i]);
> + if (err)
> + goto exit;
> + err = i2c_smbus_write_byte_data(client,
> + MAX6639_REG_OT_LIMIT(i), data->temp_ot[i]);
> + if (err)
> + goto exit;
> +
> + /* PWM 120/120 (i.e. 100%) */
> + data->pwm[i] = 120;
> + err = i2c_smbus_write_byte_data(client,
> + MAX6639_REG_TARGTDUTY(i), data->pwm[i]);
> + if (err)
> + goto exit;
> + }
> + /* Start monitoring */
> + err = i2c_smbus_write_byte_data(client, MAX6639_REG_GCONFIG,
> + MAX6639_GCONFIG_DISABLE_TIMEOUT | MAX6639_GCONFIG_CH2_LOCAL);
> +exit:
> + return err;
> +}
> +
> +/* Return 0 if detection is successful, -ENODEV otherwise */
> +static int max6639_detect(struct i2c_client *client,
> + struct i2c_board_info *info)
> +{
> + struct i2c_adapter *adapter = client->adapter;
> + int dev_id, manu_id;
> +
> + if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
> + return -ENODEV;
> +
> + /* Actual detection via device and manufacturer ID */
> + dev_id = i2c_smbus_read_byte_data(client, MAX6639_REG_DEVID);
> + manu_id = i2c_smbus_read_byte_data(client, MAX6639_REG_MANUID);
> + if (dev_id != 0x58 || manu_id != 0x4D)
> + return -ENODEV;
> +
> + strlcpy(info->type, "max6639", I2C_NAME_SIZE);
> +
> + return 0;
> +}
> +
> +static int max6639_probe(struct i2c_client *client,
> + const struct i2c_device_id *id)
> +{
> + struct max6639_data *data;
> + int err;
> +
> + data = kzalloc(sizeof(struct max6639_data), GFP_KERNEL);
> + if (!data) {
> + err = -ENOMEM;
> + goto exit;
> + }
> +
> + i2c_set_clientdata(client, data);
> + mutex_init(&data->update_lock);
> +
> + /* Initialize the max6639 chip */
> + err = max6639_init_client(client);
> + if (err < 0)
> + goto error_free;
> +
> + /* Register sysfs hooks */
> + err = sysfs_create_group(&client->dev.kobj, &max6639_group);
> + if (err)
> + goto error_free;
> +
> + data->hwmon_dev = hwmon_device_register(&client->dev);
> + if (IS_ERR(data->hwmon_dev)) {
> + err = PTR_ERR(data->hwmon_dev);
> + goto error_remove;
> + }
> +
> + dev_info(&client->dev, "temperature sensor and fan control found\n");
> +
> + return 0;
> +
> +error_remove:
> + sysfs_remove_group(&client->dev.kobj, &max6639_group);
> +error_free:
> + kfree(data);
> +exit:
> + return err;
> +}
> +
> +static int max6639_remove(struct i2c_client *client)
> +{
> + struct max6639_data *data = i2c_get_clientdata(client);
> +
> + hwmon_device_unregister(data->hwmon_dev);
> + sysfs_remove_group(&client->dev.kobj, &max6639_group);
> +
> + kfree(data);
> + return 0;
> +}
> +
> +static int max6639_suspend(struct i2c_client *client, pm_message_t mesg)
> +{
> + int data = i2c_smbus_read_byte_data(client, MAX6639_REG_GCONFIG);
> + if (data < 0)
> + return data;
> +
> + return i2c_smbus_write_byte_data(client,
> + MAX6639_REG_GCONFIG, data | MAX6639_GCONFIG_STANDBY);
> +}
> +
> +static int max6639_resume(struct i2c_client *client)
> +{
> + int data = i2c_smbus_read_byte_data(client, MAX6639_REG_GCONFIG);
> + if (data < 0)
> + return data;
> +
> + return i2c_smbus_write_byte_data(client,
> + MAX6639_REG_GCONFIG, data & ~MAX6639_GCONFIG_STANDBY);
> +}
> +
> +static const struct i2c_device_id max6639_id[] = {
> + {"max6639", 0},
> + {}
> +};
> +
> +MODULE_DEVICE_TABLE(i2c, max6639_id);
> +
> +static struct i2c_driver max6639_driver = {
> + .class = I2C_CLASS_HWMON,
> + .driver = {
> + .name = "max6639",
> + },
> + .probe = max6639_probe,
> + .remove = max6639_remove,
> + .suspend = max6639_suspend,
> + .resume = max6639_resume,
> + .id_table = max6639_id,
> + .detect = max6639_detect,
> + .address_list = normal_i2c,
> +};
> +
> +static int __init max6639_init(void)
> +{
> + return i2c_add_driver(&max6639_driver);
> +}
> +
> +static void __exit max6639_exit(void)
> +{
> + i2c_del_driver(&max6639_driver);
> +}
> +
> +MODULE_AUTHOR("Roland Stigge <stigge@antcom.de>");
> +MODULE_DESCRIPTION("max6639 driver");
> +MODULE_LICENSE("GPL");
> +
> +module_init(max6639_init);
> +module_exit(max6639_exit);
> diff --git a/include/linux/i2c/max6639.h b/include/linux/i2c/max6639.h
> new file mode 100644
> index 0000000..6011c42
> --- /dev/null
> +++ b/include/linux/i2c/max6639.h
> @@ -0,0 +1,14 @@
> +#ifndef _LINUX_MAX6639_H
> +#define _LINUX_MAX6639_H
> +
> +#include <linux/types.h>
> +
> +/* platform data for the MAX6639 temperature sensor and fan control */
> +
> +struct max6639_platform_data {
> + bool pwm_polarity; /* Polarity low (0) or high (1, default) */
> + int ppr; /* Pulses per rotation 1..4 (default = 2) */
> + int rpm_range; /* 2000, 4000 (default), 8000 or 16000 */
> +};
> +
> +#endif /* _LINUX_MAX6639_H */
>
> _______________________________________________
> lm-sensors mailing list
> lm-sensors@lm-sensors.org
> http://lists.lm-sensors.org/mailman/listinfo/lm-sensors
_______________________________________________
lm-sensors mailing list
lm-sensors@lm-sensors.org
http://lists.lm-sensors.org/mailman/listinfo/lm-sensors
^ permalink raw reply [flat|nested] 9+ messages in thread* Re: [lm-sensors] [PATCH] Added driver for Maxim MAX6639
2011-01-18 14:41 [lm-sensors] [PATCH] Added driver for Maxim MAX6639 stigge
` (6 preceding siblings ...)
2011-01-20 15:57 ` Guenter Roeck
@ 2011-01-20 17:43 ` Roland Stigge
7 siblings, 0 replies; 9+ messages in thread
From: Roland Stigge @ 2011-01-20 17:43 UTC (permalink / raw)
To: lm-sensors
Hi Guenter,
On 01/20/2011 04:57 PM, Guenter Roeck wrote:
> On Thu, Jan 20, 2011 at 06:00:54AM -0500, stigge@antcom.de wrote:
>> 2-Channel Temperature Monitor with Dual PWM Fan-Speed Controller
>>
>> Signed-off-by: Roland Stigge <stigge@antcom.de>
>>
> Hopefully the last round this time.
;-)
> On a side note, would be nice if you could provide the patch version and
> a list of changes made in resubmits.
OK, see other mail. :-)
Thanks again!
Roland
_______________________________________________
lm-sensors mailing list
lm-sensors@lm-sensors.org
http://lists.lm-sensors.org/mailman/listinfo/lm-sensors
^ permalink raw reply [flat|nested] 9+ messages in thread