1/* 2 * emc1403.c - SMSC Thermal Driver 3 * 4 * Copyright (C) 2008 Intel Corp 5 * 6 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; version 2 of the License. 11 * 12 * This program is distributed in the hope that it will be useful, but 13 * WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 * General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License along 18 * with this program; if not, write to the Free Software Foundation, Inc., 19 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. 20 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 21 * 22 * TODO 23 * - cache alarm and critical limit registers 24 * - add emc1404 support 25 */ 26 27#include <linux/module.h> 28#include <linux/init.h> 29#include <linux/slab.h> 30#include <linux/i2c.h> 31#include <linux/hwmon.h> 32#include <linux/hwmon-sysfs.h> 33#include <linux/err.h> 34#include <linux/sysfs.h> 35#include <linux/mutex.h> 36 37#define THERMAL_PID_REG 0xfd 38#define THERMAL_SMSC_ID_REG 0xfe 39#define THERMAL_REVISION_REG 0xff 40 41struct thermal_data { 42 struct device *hwmon_dev; 43 struct mutex mutex; 44 /* Cache the hyst value so we don't keep re-reading it. In theory 45 we could cache it forever as nobody else should be writing it. */ 46 u8 cached_hyst; 47 unsigned long hyst_valid; 48}; 49 50static ssize_t show_temp(struct device *dev, 51 struct device_attribute *attr, char *buf) 52{ 53 struct i2c_client *client = to_i2c_client(dev); 54 struct sensor_device_attribute *sda = to_sensor_dev_attr(attr); 55 int retval = i2c_smbus_read_byte_data(client, sda->index); 56 57 if (retval < 0) 58 return retval; 59 return sprintf(buf, "%d000\n", retval); 60} 61 62static ssize_t show_bit(struct device *dev, 63 struct device_attribute *attr, char *buf) 64{ 65 struct i2c_client *client = to_i2c_client(dev); 66 struct sensor_device_attribute_2 *sda = to_sensor_dev_attr_2(attr); 67 int retval = i2c_smbus_read_byte_data(client, sda->nr); 68 69 if (retval < 0) 70 return retval; 71 retval &= sda->index; 72 return sprintf(buf, "%d\n", retval ? 1 : 0); 73} 74 75static ssize_t store_temp(struct device *dev, 76 struct device_attribute *attr, const char *buf, size_t count) 77{ 78 struct sensor_device_attribute *sda = to_sensor_dev_attr(attr); 79 struct i2c_client *client = to_i2c_client(dev); 80 unsigned long val; 81 int retval; 82 83 if (strict_strtoul(buf, 10, &val)) 84 return -EINVAL; 85 retval = i2c_smbus_write_byte_data(client, sda->index, 86 DIV_ROUND_CLOSEST(val, 1000)); 87 if (retval < 0) 88 return retval; 89 return count; 90} 91 92static ssize_t store_bit(struct device *dev, 93 struct device_attribute *attr, const char *buf, size_t count) 94{ 95 struct i2c_client *client = to_i2c_client(dev); 96 struct thermal_data *data = i2c_get_clientdata(client); 97 struct sensor_device_attribute_2 *sda = to_sensor_dev_attr_2(attr); 98 unsigned long val; 99 int retval; 100 101 if (strict_strtoul(buf, 10, &val)) 102 return -EINVAL; 103 104 mutex_lock(&data->mutex); 105 retval = i2c_smbus_read_byte_data(client, sda->nr); 106 if (retval < 0) 107 goto fail; 108 109 retval &= ~sda->index; 110 if (val) 111 retval |= sda->index; 112 113 retval = i2c_smbus_write_byte_data(client, sda->index, retval); 114 if (retval == 0) 115 retval = count; 116fail: 117 mutex_unlock(&data->mutex); 118 return retval; 119} 120 121static ssize_t show_hyst(struct device *dev, 122 struct device_attribute *attr, char *buf) 123{ 124 struct i2c_client *client = to_i2c_client(dev); 125 struct thermal_data *data = i2c_get_clientdata(client); 126 struct sensor_device_attribute *sda = to_sensor_dev_attr(attr); 127 int retval; 128 int hyst; 129 130 retval = i2c_smbus_read_byte_data(client, sda->index); 131 if (retval < 0) 132 return retval; 133 134 if (time_after(jiffies, data->hyst_valid)) { 135 hyst = i2c_smbus_read_byte_data(client, 0x21); 136 if (hyst < 0) 137 return retval; 138 data->cached_hyst = hyst; 139 data->hyst_valid = jiffies + HZ; 140 } 141 return sprintf(buf, "%d000\n", retval - data->cached_hyst); 142} 143 144static ssize_t store_hyst(struct device *dev, 145 struct device_attribute *attr, const char *buf, size_t count) 146{ 147 struct i2c_client *client = to_i2c_client(dev); 148 struct thermal_data *data = i2c_get_clientdata(client); 149 struct sensor_device_attribute *sda = to_sensor_dev_attr(attr); 150 int retval; 151 int hyst; 152 unsigned long val; 153 154 if (strict_strtoul(buf, 10, &val)) 155 return -EINVAL; 156 157 mutex_lock(&data->mutex); 158 retval = i2c_smbus_read_byte_data(client, sda->index); 159 if (retval < 0) 160 goto fail; 161 162 hyst = val - retval * 1000; 163 hyst = DIV_ROUND_CLOSEST(hyst, 1000); 164 if (hyst < 0 || hyst > 255) { 165 retval = -ERANGE; 166 goto fail; 167 } 168 169 retval = i2c_smbus_write_byte_data(client, 0x21, hyst); 170 if (retval == 0) { 171 retval = count; 172 data->cached_hyst = hyst; 173 data->hyst_valid = jiffies + HZ; 174 } 175fail: 176 mutex_unlock(&data->mutex); 177 return retval; 178} 179 180/* 181 * Sensors. We pass the actual i2c register to the methods. 182 */ 183 184static SENSOR_DEVICE_ATTR(temp1_min, S_IRUGO | S_IWUSR, 185 show_temp, store_temp, 0x06); 186static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR, 187 show_temp, store_temp, 0x05); 188static SENSOR_DEVICE_ATTR(temp1_crit, S_IRUGO | S_IWUSR, 189 show_temp, store_temp, 0x20); 190static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0x00); 191static SENSOR_DEVICE_ATTR_2(temp1_min_alarm, S_IRUGO, 192 show_bit, NULL, 0x36, 0x01); 193static SENSOR_DEVICE_ATTR_2(temp1_max_alarm, S_IRUGO, 194 show_bit, NULL, 0x35, 0x01); 195static SENSOR_DEVICE_ATTR_2(temp1_crit_alarm, S_IRUGO, 196 show_bit, NULL, 0x37, 0x01); 197static SENSOR_DEVICE_ATTR(temp1_crit_hyst, S_IRUGO | S_IWUSR, 198 show_hyst, store_hyst, 0x20); 199 200static SENSOR_DEVICE_ATTR(temp2_min, S_IRUGO | S_IWUSR, 201 show_temp, store_temp, 0x08); 202static SENSOR_DEVICE_ATTR(temp2_max, S_IRUGO | S_IWUSR, 203 show_temp, store_temp, 0x07); 204static SENSOR_DEVICE_ATTR(temp2_crit, S_IRUGO | S_IWUSR, 205 show_temp, store_temp, 0x19); 206static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 0x01); 207static SENSOR_DEVICE_ATTR_2(temp2_min_alarm, S_IRUGO, 208 show_bit, NULL, 0x36, 0x02); 209static SENSOR_DEVICE_ATTR_2(temp2_max_alarm, S_IRUGO, 210 show_bit, NULL, 0x35, 0x02); 211static SENSOR_DEVICE_ATTR_2(temp2_crit_alarm, S_IRUGO, 212 show_bit, NULL, 0x37, 0x02); 213static SENSOR_DEVICE_ATTR(temp2_crit_hyst, S_IRUGO | S_IWUSR, 214 show_hyst, store_hyst, 0x19); 215 216static SENSOR_DEVICE_ATTR(temp3_min, S_IRUGO | S_IWUSR, 217 show_temp, store_temp, 0x16); 218static SENSOR_DEVICE_ATTR(temp3_max, S_IRUGO | S_IWUSR, 219 show_temp, store_temp, 0x15); 220static SENSOR_DEVICE_ATTR(temp3_crit, S_IRUGO | S_IWUSR, 221 show_temp, store_temp, 0x1A); 222static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, show_temp, NULL, 0x23); 223static SENSOR_DEVICE_ATTR_2(temp3_min_alarm, S_IRUGO, 224 show_bit, NULL, 0x36, 0x04); 225static SENSOR_DEVICE_ATTR_2(temp3_max_alarm, S_IRUGO, 226 show_bit, NULL, 0x35, 0x04); 227static SENSOR_DEVICE_ATTR_2(temp3_crit_alarm, S_IRUGO, 228 show_bit, NULL, 0x37, 0x04); 229static SENSOR_DEVICE_ATTR(temp3_crit_hyst, S_IRUGO | S_IWUSR, 230 show_hyst, store_hyst, 0x1A); 231 232static SENSOR_DEVICE_ATTR_2(power_state, S_IRUGO | S_IWUSR, 233 show_bit, store_bit, 0x03, 0x40); 234 235static struct attribute *mid_att_thermal[] = { 236 &sensor_dev_attr_temp1_min.dev_attr.attr, 237 &sensor_dev_attr_temp1_max.dev_attr.attr, 238 &sensor_dev_attr_temp1_crit.dev_attr.attr, 239 &sensor_dev_attr_temp1_input.dev_attr.attr, 240 &sensor_dev_attr_temp1_min_alarm.dev_attr.attr, 241 &sensor_dev_attr_temp1_max_alarm.dev_attr.attr, 242 &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr, 243 &sensor_dev_attr_temp1_crit_hyst.dev_attr.attr, 244 &sensor_dev_attr_temp2_min.dev_attr.attr, 245 &sensor_dev_attr_temp2_max.dev_attr.attr, 246 &sensor_dev_attr_temp2_crit.dev_attr.attr, 247 &sensor_dev_attr_temp2_input.dev_attr.attr, 248 &sensor_dev_attr_temp2_min_alarm.dev_attr.attr, 249 &sensor_dev_attr_temp2_max_alarm.dev_attr.attr, 250 &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr, 251 &sensor_dev_attr_temp2_crit_hyst.dev_attr.attr, 252 &sensor_dev_attr_temp3_min.dev_attr.attr, 253 &sensor_dev_attr_temp3_max.dev_attr.attr, 254 &sensor_dev_attr_temp3_crit.dev_attr.attr, 255 &sensor_dev_attr_temp3_input.dev_attr.attr, 256 &sensor_dev_attr_temp3_min_alarm.dev_attr.attr, 257 &sensor_dev_attr_temp3_max_alarm.dev_attr.attr, 258 &sensor_dev_attr_temp3_crit_alarm.dev_attr.attr, 259 &sensor_dev_attr_temp3_crit_hyst.dev_attr.attr, 260 &sensor_dev_attr_power_state.dev_attr.attr, 261 NULL 262}; 263 264static const struct attribute_group m_thermal_gr = { 265 .attrs = mid_att_thermal 266}; 267 268static int emc1403_detect(struct i2c_client *client, 269 struct i2c_board_info *info) 270{ 271 int id; 272 /* Check if thermal chip is SMSC and EMC1403 */ 273 274 id = i2c_smbus_read_byte_data(client, THERMAL_SMSC_ID_REG); 275 if (id != 0x5d) 276 return -ENODEV; 277 278 /* Note: 0x25 is the 1404 which is very similar and this 279 driver could be extended */ 280 id = i2c_smbus_read_byte_data(client, THERMAL_PID_REG); 281 if (id != 0x21) 282 return -ENODEV; 283 284 id = i2c_smbus_read_byte_data(client, THERMAL_REVISION_REG); 285 if (id != 0x01) 286 return -ENODEV; 287 288 strlcpy(info->type, "emc1403", I2C_NAME_SIZE); 289 return 0; 290} 291 292static int emc1403_probe(struct i2c_client *client, 293 const struct i2c_device_id *id) 294{ 295 int res; 296 struct thermal_data *data; 297 298 data = kzalloc(sizeof(struct thermal_data), GFP_KERNEL); 299 if (data == NULL) { 300 dev_warn(&client->dev, "out of memory"); 301 return -ENOMEM; 302 } 303 304 i2c_set_clientdata(client, data); 305 mutex_init(&data->mutex); 306 data->hyst_valid = jiffies - 1; /* Expired */ 307 308 res = sysfs_create_group(&client->dev.kobj, &m_thermal_gr); 309 if (res) { 310 dev_warn(&client->dev, "create group failed\n"); 311 goto thermal_error1; 312 } 313 data->hwmon_dev = hwmon_device_register(&client->dev); 314 if (IS_ERR(data->hwmon_dev)) { 315 res = PTR_ERR(data->hwmon_dev); 316 dev_warn(&client->dev, "register hwmon dev failed\n"); 317 goto thermal_error2; 318 } 319 dev_info(&client->dev, "EMC1403 Thermal chip found\n"); 320 return res; 321 322thermal_error2: 323 sysfs_remove_group(&client->dev.kobj, &m_thermal_gr); 324thermal_error1: 325 kfree(data); 326 return res; 327} 328 329static int emc1403_remove(struct i2c_client *client) 330{ 331 struct thermal_data *data = i2c_get_clientdata(client); 332 333 hwmon_device_unregister(data->hwmon_dev); 334 sysfs_remove_group(&client->dev.kobj, &m_thermal_gr); 335 kfree(data); 336 return 0; 337} 338 339static const unsigned short emc1403_address_list[] = { 340 0x18, 0x2a, 0x4c, 0x4d, I2C_CLIENT_END 341}; 342 343static const struct i2c_device_id emc1403_idtable[] = { 344 { "emc1403", 0 }, 345 { } 346}; 347MODULE_DEVICE_TABLE(i2c, emc1403_idtable); 348 349static struct i2c_driver sensor_emc1403 = { 350 .class = I2C_CLASS_HWMON, 351 .driver = { 352 .name = "emc1403", 353 }, 354 .detect = emc1403_detect, 355 .probe = emc1403_probe, 356 .remove = emc1403_remove, 357 .id_table = emc1403_idtable, 358 .address_list = emc1403_address_list, 359}; 360 361static int __init sensor_emc1403_init(void) 362{ 363 return i2c_add_driver(&sensor_emc1403); 364} 365 366static void __exit sensor_emc1403_exit(void) 367{ 368 i2c_del_driver(&sensor_emc1403); 369} 370 371module_init(sensor_emc1403_init); 372module_exit(sensor_emc1403_exit); 373 374MODULE_AUTHOR("Kalhan Trisal <kalhan.trisal@intel.com"); 375MODULE_DESCRIPTION("emc1403 Thermal Driver"); 376MODULE_LICENSE("GPL v2"); 377