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 */ 25 26 #include <linux/module.h> 27 #include <linux/init.h> 28 #include <linux/slab.h> 29 #include <linux/i2c.h> 30 #include <linux/hwmon.h> 31 #include <linux/hwmon-sysfs.h> 32 #include <linux/err.h> 33 #include <linux/sysfs.h> 34 #include <linux/mutex.h> 35 #include <linux/jiffies.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 i2c_client *client; 43 const struct attribute_group *groups[3]; 44 struct mutex mutex; 45 /* 46 * Cache the hyst value so we don't keep re-reading it. In theory 47 * we could cache it forever as nobody else should be writing it. 48 */ 49 u8 cached_hyst; 50 unsigned long hyst_valid; 51 }; 52 53 static ssize_t show_temp(struct device *dev, 54 struct device_attribute *attr, char *buf) 55 { 56 struct sensor_device_attribute *sda = to_sensor_dev_attr(attr); 57 struct thermal_data *data = dev_get_drvdata(dev); 58 int retval; 59 60 retval = i2c_smbus_read_byte_data(data->client, sda->index); 61 if (retval < 0) 62 return retval; 63 return sprintf(buf, "%d000\n", retval); 64 } 65 66 static ssize_t show_bit(struct device *dev, 67 struct device_attribute *attr, char *buf) 68 { 69 struct sensor_device_attribute_2 *sda = to_sensor_dev_attr_2(attr); 70 struct thermal_data *data = dev_get_drvdata(dev); 71 int retval; 72 73 retval = i2c_smbus_read_byte_data(data->client, sda->nr); 74 if (retval < 0) 75 return retval; 76 return sprintf(buf, "%d\n", !!(retval & sda->index)); 77 } 78 79 static ssize_t store_temp(struct device *dev, 80 struct device_attribute *attr, const char *buf, size_t count) 81 { 82 struct sensor_device_attribute *sda = to_sensor_dev_attr(attr); 83 struct thermal_data *data = dev_get_drvdata(dev); 84 unsigned long val; 85 int retval; 86 87 if (kstrtoul(buf, 10, &val)) 88 return -EINVAL; 89 retval = i2c_smbus_write_byte_data(data->client, sda->index, 90 DIV_ROUND_CLOSEST(val, 1000)); 91 if (retval < 0) 92 return retval; 93 return count; 94 } 95 96 static ssize_t store_bit(struct device *dev, 97 struct device_attribute *attr, const char *buf, size_t count) 98 { 99 struct sensor_device_attribute_2 *sda = to_sensor_dev_attr_2(attr); 100 struct thermal_data *data = dev_get_drvdata(dev); 101 struct i2c_client *client = data->client; 102 unsigned long val; 103 int retval; 104 105 if (kstrtoul(buf, 10, &val)) 106 return -EINVAL; 107 108 mutex_lock(&data->mutex); 109 retval = i2c_smbus_read_byte_data(client, sda->nr); 110 if (retval < 0) 111 goto fail; 112 113 retval &= ~sda->index; 114 if (val) 115 retval |= sda->index; 116 117 retval = i2c_smbus_write_byte_data(client, sda->index, retval); 118 if (retval == 0) 119 retval = count; 120 fail: 121 mutex_unlock(&data->mutex); 122 return retval; 123 } 124 125 static ssize_t show_hyst(struct device *dev, 126 struct device_attribute *attr, char *buf) 127 { 128 struct sensor_device_attribute *sda = to_sensor_dev_attr(attr); 129 struct thermal_data *data = dev_get_drvdata(dev); 130 struct i2c_client *client = data->client; 131 int retval; 132 int hyst; 133 134 retval = i2c_smbus_read_byte_data(client, sda->index); 135 if (retval < 0) 136 return retval; 137 138 if (time_after(jiffies, data->hyst_valid)) { 139 hyst = i2c_smbus_read_byte_data(client, 0x21); 140 if (hyst < 0) 141 return retval; 142 data->cached_hyst = hyst; 143 data->hyst_valid = jiffies + HZ; 144 } 145 return sprintf(buf, "%d000\n", retval - data->cached_hyst); 146 } 147 148 static ssize_t store_hyst(struct device *dev, 149 struct device_attribute *attr, const char *buf, size_t count) 150 { 151 struct sensor_device_attribute *sda = to_sensor_dev_attr(attr); 152 struct thermal_data *data = dev_get_drvdata(dev); 153 struct i2c_client *client = data->client; 154 int retval; 155 int hyst; 156 unsigned long val; 157 158 if (kstrtoul(buf, 10, &val)) 159 return -EINVAL; 160 161 mutex_lock(&data->mutex); 162 retval = i2c_smbus_read_byte_data(client, sda->index); 163 if (retval < 0) 164 goto fail; 165 166 hyst = val - retval * 1000; 167 hyst = DIV_ROUND_CLOSEST(hyst, 1000); 168 if (hyst < 0 || hyst > 255) { 169 retval = -ERANGE; 170 goto fail; 171 } 172 173 retval = i2c_smbus_write_byte_data(client, 0x21, hyst); 174 if (retval == 0) { 175 retval = count; 176 data->cached_hyst = hyst; 177 data->hyst_valid = jiffies + HZ; 178 } 179 fail: 180 mutex_unlock(&data->mutex); 181 return retval; 182 } 183 184 /* 185 * Sensors. We pass the actual i2c register to the methods. 186 */ 187 188 static SENSOR_DEVICE_ATTR(temp1_min, S_IRUGO | S_IWUSR, 189 show_temp, store_temp, 0x06); 190 static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR, 191 show_temp, store_temp, 0x05); 192 static SENSOR_DEVICE_ATTR(temp1_crit, S_IRUGO | S_IWUSR, 193 show_temp, store_temp, 0x20); 194 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0x00); 195 static SENSOR_DEVICE_ATTR_2(temp1_min_alarm, S_IRUGO, 196 show_bit, NULL, 0x36, 0x01); 197 static SENSOR_DEVICE_ATTR_2(temp1_max_alarm, S_IRUGO, 198 show_bit, NULL, 0x35, 0x01); 199 static SENSOR_DEVICE_ATTR_2(temp1_crit_alarm, S_IRUGO, 200 show_bit, NULL, 0x37, 0x01); 201 static SENSOR_DEVICE_ATTR(temp1_crit_hyst, S_IRUGO | S_IWUSR, 202 show_hyst, store_hyst, 0x20); 203 204 static SENSOR_DEVICE_ATTR(temp2_min, S_IRUGO | S_IWUSR, 205 show_temp, store_temp, 0x08); 206 static SENSOR_DEVICE_ATTR(temp2_max, S_IRUGO | S_IWUSR, 207 show_temp, store_temp, 0x07); 208 static SENSOR_DEVICE_ATTR(temp2_crit, S_IRUGO | S_IWUSR, 209 show_temp, store_temp, 0x19); 210 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 0x01); 211 static SENSOR_DEVICE_ATTR_2(temp2_min_alarm, S_IRUGO, 212 show_bit, NULL, 0x36, 0x02); 213 static SENSOR_DEVICE_ATTR_2(temp2_max_alarm, S_IRUGO, 214 show_bit, NULL, 0x35, 0x02); 215 static SENSOR_DEVICE_ATTR_2(temp2_crit_alarm, S_IRUGO, 216 show_bit, NULL, 0x37, 0x02); 217 static SENSOR_DEVICE_ATTR(temp2_crit_hyst, S_IRUGO | S_IWUSR, 218 show_hyst, store_hyst, 0x19); 219 220 static SENSOR_DEVICE_ATTR(temp3_min, S_IRUGO | S_IWUSR, 221 show_temp, store_temp, 0x16); 222 static SENSOR_DEVICE_ATTR(temp3_max, S_IRUGO | S_IWUSR, 223 show_temp, store_temp, 0x15); 224 static SENSOR_DEVICE_ATTR(temp3_crit, S_IRUGO | S_IWUSR, 225 show_temp, store_temp, 0x1A); 226 static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, show_temp, NULL, 0x23); 227 static SENSOR_DEVICE_ATTR_2(temp3_min_alarm, S_IRUGO, 228 show_bit, NULL, 0x36, 0x04); 229 static SENSOR_DEVICE_ATTR_2(temp3_max_alarm, S_IRUGO, 230 show_bit, NULL, 0x35, 0x04); 231 static SENSOR_DEVICE_ATTR_2(temp3_crit_alarm, S_IRUGO, 232 show_bit, NULL, 0x37, 0x04); 233 static SENSOR_DEVICE_ATTR(temp3_crit_hyst, S_IRUGO | S_IWUSR, 234 show_hyst, store_hyst, 0x1A); 235 236 static SENSOR_DEVICE_ATTR(temp4_min, S_IRUGO | S_IWUSR, 237 show_temp, store_temp, 0x2D); 238 static SENSOR_DEVICE_ATTR(temp4_max, S_IRUGO | S_IWUSR, 239 show_temp, store_temp, 0x2C); 240 static SENSOR_DEVICE_ATTR(temp4_crit, S_IRUGO | S_IWUSR, 241 show_temp, store_temp, 0x30); 242 static SENSOR_DEVICE_ATTR(temp4_input, S_IRUGO, show_temp, NULL, 0x2A); 243 static SENSOR_DEVICE_ATTR_2(temp4_min_alarm, S_IRUGO, 244 show_bit, NULL, 0x36, 0x08); 245 static SENSOR_DEVICE_ATTR_2(temp4_max_alarm, S_IRUGO, 246 show_bit, NULL, 0x35, 0x08); 247 static SENSOR_DEVICE_ATTR_2(temp4_crit_alarm, S_IRUGO, 248 show_bit, NULL, 0x37, 0x08); 249 static SENSOR_DEVICE_ATTR(temp4_crit_hyst, S_IRUGO | S_IWUSR, 250 show_hyst, store_hyst, 0x30); 251 252 static SENSOR_DEVICE_ATTR_2(power_state, S_IRUGO | S_IWUSR, 253 show_bit, store_bit, 0x03, 0x40); 254 255 static struct attribute *emc1403_attrs[] = { 256 &sensor_dev_attr_temp1_min.dev_attr.attr, 257 &sensor_dev_attr_temp1_max.dev_attr.attr, 258 &sensor_dev_attr_temp1_crit.dev_attr.attr, 259 &sensor_dev_attr_temp1_input.dev_attr.attr, 260 &sensor_dev_attr_temp1_min_alarm.dev_attr.attr, 261 &sensor_dev_attr_temp1_max_alarm.dev_attr.attr, 262 &sensor_dev_attr_temp1_crit_alarm.dev_attr.attr, 263 &sensor_dev_attr_temp1_crit_hyst.dev_attr.attr, 264 &sensor_dev_attr_temp2_min.dev_attr.attr, 265 &sensor_dev_attr_temp2_max.dev_attr.attr, 266 &sensor_dev_attr_temp2_crit.dev_attr.attr, 267 &sensor_dev_attr_temp2_input.dev_attr.attr, 268 &sensor_dev_attr_temp2_min_alarm.dev_attr.attr, 269 &sensor_dev_attr_temp2_max_alarm.dev_attr.attr, 270 &sensor_dev_attr_temp2_crit_alarm.dev_attr.attr, 271 &sensor_dev_attr_temp2_crit_hyst.dev_attr.attr, 272 &sensor_dev_attr_temp3_min.dev_attr.attr, 273 &sensor_dev_attr_temp3_max.dev_attr.attr, 274 &sensor_dev_attr_temp3_crit.dev_attr.attr, 275 &sensor_dev_attr_temp3_input.dev_attr.attr, 276 &sensor_dev_attr_temp3_min_alarm.dev_attr.attr, 277 &sensor_dev_attr_temp3_max_alarm.dev_attr.attr, 278 &sensor_dev_attr_temp3_crit_alarm.dev_attr.attr, 279 &sensor_dev_attr_temp3_crit_hyst.dev_attr.attr, 280 &sensor_dev_attr_power_state.dev_attr.attr, 281 NULL 282 }; 283 284 static const struct attribute_group emc1403_group = { 285 .attrs = emc1403_attrs, 286 }; 287 288 static struct attribute *emc1404_attrs[] = { 289 &sensor_dev_attr_temp4_min.dev_attr.attr, 290 &sensor_dev_attr_temp4_max.dev_attr.attr, 291 &sensor_dev_attr_temp4_crit.dev_attr.attr, 292 &sensor_dev_attr_temp4_input.dev_attr.attr, 293 &sensor_dev_attr_temp4_min_alarm.dev_attr.attr, 294 &sensor_dev_attr_temp4_max_alarm.dev_attr.attr, 295 &sensor_dev_attr_temp4_crit_alarm.dev_attr.attr, 296 &sensor_dev_attr_temp4_crit_hyst.dev_attr.attr, 297 NULL 298 }; 299 300 static const struct attribute_group emc1404_group = { 301 .attrs = emc1404_attrs, 302 }; 303 304 static int emc1403_detect(struct i2c_client *client, 305 struct i2c_board_info *info) 306 { 307 int id; 308 /* Check if thermal chip is SMSC and EMC1403 or EMC1423 */ 309 310 id = i2c_smbus_read_byte_data(client, THERMAL_SMSC_ID_REG); 311 if (id != 0x5d) 312 return -ENODEV; 313 314 id = i2c_smbus_read_byte_data(client, THERMAL_PID_REG); 315 switch (id) { 316 case 0x21: 317 strlcpy(info->type, "emc1403", I2C_NAME_SIZE); 318 break; 319 case 0x23: 320 strlcpy(info->type, "emc1423", I2C_NAME_SIZE); 321 break; 322 case 0x25: 323 strlcpy(info->type, "emc1404", I2C_NAME_SIZE); 324 break; 325 case 0x27: 326 strlcpy(info->type, "emc1424", I2C_NAME_SIZE); 327 break; 328 default: 329 return -ENODEV; 330 } 331 332 id = i2c_smbus_read_byte_data(client, THERMAL_REVISION_REG); 333 if (id != 0x01) 334 return -ENODEV; 335 336 return 0; 337 } 338 339 static int emc1403_probe(struct i2c_client *client, 340 const struct i2c_device_id *id) 341 { 342 struct thermal_data *data; 343 struct device *hwmon_dev; 344 345 data = devm_kzalloc(&client->dev, sizeof(struct thermal_data), 346 GFP_KERNEL); 347 if (data == NULL) 348 return -ENOMEM; 349 350 data->client = client; 351 mutex_init(&data->mutex); 352 data->hyst_valid = jiffies - 1; /* Expired */ 353 354 data->groups[0] = &emc1403_group; 355 if (id->driver_data) 356 data->groups[1] = &emc1404_group; 357 358 hwmon_dev = hwmon_device_register_with_groups(&client->dev, 359 client->name, data, 360 data->groups); 361 if (IS_ERR(hwmon_dev)) 362 return PTR_ERR(hwmon_dev); 363 364 dev_info(&client->dev, "%s Thermal chip found\n", id->name); 365 return 0; 366 } 367 368 static const unsigned short emc1403_address_list[] = { 369 0x18, 0x29, 0x4c, 0x4d, I2C_CLIENT_END 370 }; 371 372 static const struct i2c_device_id emc1403_idtable[] = { 373 { "emc1403", 0 }, 374 { "emc1404", 1 }, 375 { "emc1423", 0 }, 376 { "emc1424", 1 }, 377 { } 378 }; 379 MODULE_DEVICE_TABLE(i2c, emc1403_idtable); 380 381 static struct i2c_driver sensor_emc1403 = { 382 .class = I2C_CLASS_HWMON, 383 .driver = { 384 .name = "emc1403", 385 }, 386 .detect = emc1403_detect, 387 .probe = emc1403_probe, 388 .id_table = emc1403_idtable, 389 .address_list = emc1403_address_list, 390 }; 391 392 module_i2c_driver(sensor_emc1403); 393 394 MODULE_AUTHOR("Kalhan Trisal <kalhan.trisal@intel.com"); 395 MODULE_DESCRIPTION("emc1403 Thermal Driver"); 396 MODULE_LICENSE("GPL v2"); 397