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 41 struct 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 50 static 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 62 static 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 75 static 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 92 static 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; 116 fail: 117 mutex_unlock(&data->mutex); 118 return retval; 119 } 120 121 static 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 144 static 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 } 175 fail: 176 mutex_unlock(&data->mutex); 177 return retval; 178 } 179 180 /* 181 * Sensors. We pass the actual i2c register to the methods. 182 */ 183 184 static SENSOR_DEVICE_ATTR(temp1_min, S_IRUGO | S_IWUSR, 185 show_temp, store_temp, 0x06); 186 static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR, 187 show_temp, store_temp, 0x05); 188 static SENSOR_DEVICE_ATTR(temp1_crit, S_IRUGO | S_IWUSR, 189 show_temp, store_temp, 0x20); 190 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0x00); 191 static SENSOR_DEVICE_ATTR_2(temp1_min_alarm, S_IRUGO, 192 show_bit, NULL, 0x36, 0x01); 193 static SENSOR_DEVICE_ATTR_2(temp1_max_alarm, S_IRUGO, 194 show_bit, NULL, 0x35, 0x01); 195 static SENSOR_DEVICE_ATTR_2(temp1_crit_alarm, S_IRUGO, 196 show_bit, NULL, 0x37, 0x01); 197 static SENSOR_DEVICE_ATTR(temp1_crit_hyst, S_IRUGO | S_IWUSR, 198 show_hyst, store_hyst, 0x20); 199 200 static SENSOR_DEVICE_ATTR(temp2_min, S_IRUGO | S_IWUSR, 201 show_temp, store_temp, 0x08); 202 static SENSOR_DEVICE_ATTR(temp2_max, S_IRUGO | S_IWUSR, 203 show_temp, store_temp, 0x07); 204 static SENSOR_DEVICE_ATTR(temp2_crit, S_IRUGO | S_IWUSR, 205 show_temp, store_temp, 0x19); 206 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 0x01); 207 static SENSOR_DEVICE_ATTR_2(temp2_min_alarm, S_IRUGO, 208 show_bit, NULL, 0x36, 0x02); 209 static SENSOR_DEVICE_ATTR_2(temp2_max_alarm, S_IRUGO, 210 show_bit, NULL, 0x35, 0x02); 211 static SENSOR_DEVICE_ATTR_2(temp2_crit_alarm, S_IRUGO, 212 show_bit, NULL, 0x37, 0x02); 213 static SENSOR_DEVICE_ATTR(temp2_crit_hyst, S_IRUGO | S_IWUSR, 214 show_hyst, store_hyst, 0x19); 215 216 static SENSOR_DEVICE_ATTR(temp3_min, S_IRUGO | S_IWUSR, 217 show_temp, store_temp, 0x16); 218 static SENSOR_DEVICE_ATTR(temp3_max, S_IRUGO | S_IWUSR, 219 show_temp, store_temp, 0x15); 220 static SENSOR_DEVICE_ATTR(temp3_crit, S_IRUGO | S_IWUSR, 221 show_temp, store_temp, 0x1A); 222 static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, show_temp, NULL, 0x23); 223 static SENSOR_DEVICE_ATTR_2(temp3_min_alarm, S_IRUGO, 224 show_bit, NULL, 0x36, 0x04); 225 static SENSOR_DEVICE_ATTR_2(temp3_max_alarm, S_IRUGO, 226 show_bit, NULL, 0x35, 0x04); 227 static SENSOR_DEVICE_ATTR_2(temp3_crit_alarm, S_IRUGO, 228 show_bit, NULL, 0x37, 0x04); 229 static SENSOR_DEVICE_ATTR(temp3_crit_hyst, S_IRUGO | S_IWUSR, 230 show_hyst, store_hyst, 0x1A); 231 232 static SENSOR_DEVICE_ATTR_2(power_state, S_IRUGO | S_IWUSR, 233 show_bit, store_bit, 0x03, 0x40); 234 235 static 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 264 static const struct attribute_group m_thermal_gr = { 265 .attrs = mid_att_thermal 266 }; 267 268 static 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 or EMC1423 */ 273 274 id = i2c_smbus_read_byte_data(client, THERMAL_SMSC_ID_REG); 275 if (id != 0x5d) 276 return -ENODEV; 277 278 id = i2c_smbus_read_byte_data(client, THERMAL_PID_REG); 279 switch (id) { 280 case 0x21: 281 strlcpy(info->type, "emc1403", I2C_NAME_SIZE); 282 break; 283 case 0x23: 284 strlcpy(info->type, "emc1423", I2C_NAME_SIZE); 285 break; 286 /* Note: 0x25 is the 1404 which is very similar and this 287 driver could be extended */ 288 default: 289 return -ENODEV; 290 } 291 292 id = i2c_smbus_read_byte_data(client, THERMAL_REVISION_REG); 293 if (id != 0x01) 294 return -ENODEV; 295 296 return 0; 297 } 298 299 static int emc1403_probe(struct i2c_client *client, 300 const struct i2c_device_id *id) 301 { 302 int res; 303 struct thermal_data *data; 304 305 data = kzalloc(sizeof(struct thermal_data), GFP_KERNEL); 306 if (data == NULL) { 307 dev_warn(&client->dev, "out of memory"); 308 return -ENOMEM; 309 } 310 311 i2c_set_clientdata(client, data); 312 mutex_init(&data->mutex); 313 data->hyst_valid = jiffies - 1; /* Expired */ 314 315 res = sysfs_create_group(&client->dev.kobj, &m_thermal_gr); 316 if (res) { 317 dev_warn(&client->dev, "create group failed\n"); 318 goto thermal_error1; 319 } 320 data->hwmon_dev = hwmon_device_register(&client->dev); 321 if (IS_ERR(data->hwmon_dev)) { 322 res = PTR_ERR(data->hwmon_dev); 323 dev_warn(&client->dev, "register hwmon dev failed\n"); 324 goto thermal_error2; 325 } 326 dev_info(&client->dev, "EMC1403 Thermal chip found\n"); 327 return res; 328 329 thermal_error2: 330 sysfs_remove_group(&client->dev.kobj, &m_thermal_gr); 331 thermal_error1: 332 kfree(data); 333 return res; 334 } 335 336 static int emc1403_remove(struct i2c_client *client) 337 { 338 struct thermal_data *data = i2c_get_clientdata(client); 339 340 hwmon_device_unregister(data->hwmon_dev); 341 sysfs_remove_group(&client->dev.kobj, &m_thermal_gr); 342 kfree(data); 343 return 0; 344 } 345 346 static const unsigned short emc1403_address_list[] = { 347 0x18, 0x29, 0x4c, 0x4d, I2C_CLIENT_END 348 }; 349 350 static const struct i2c_device_id emc1403_idtable[] = { 351 { "emc1403", 0 }, 352 { "emc1423", 0 }, 353 { } 354 }; 355 MODULE_DEVICE_TABLE(i2c, emc1403_idtable); 356 357 static struct i2c_driver sensor_emc1403 = { 358 .class = I2C_CLASS_HWMON, 359 .driver = { 360 .name = "emc1403", 361 }, 362 .detect = emc1403_detect, 363 .probe = emc1403_probe, 364 .remove = emc1403_remove, 365 .id_table = emc1403_idtable, 366 .address_list = emc1403_address_list, 367 }; 368 369 static int __init sensor_emc1403_init(void) 370 { 371 return i2c_add_driver(&sensor_emc1403); 372 } 373 374 static void __exit sensor_emc1403_exit(void) 375 { 376 i2c_del_driver(&sensor_emc1403); 377 } 378 379 module_init(sensor_emc1403_init); 380 module_exit(sensor_emc1403_exit); 381 382 MODULE_AUTHOR("Kalhan Trisal <kalhan.trisal@intel.com"); 383 MODULE_DESCRIPTION("emc1403 Thermal Driver"); 384 MODULE_LICENSE("GPL v2"); 385