1 /* 2 adm1021.c - Part of lm_sensors, Linux kernel modules for hardware 3 monitoring 4 Copyright (c) 1998, 1999 Frodo Looijaard <frodol@dds.nl> and 5 Philip Edelbrock <phil@netroedge.com> 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 2 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program; if not, write to the Free Software 19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 */ 21 22 #include <linux/module.h> 23 #include <linux/init.h> 24 #include <linux/slab.h> 25 #include <linux/jiffies.h> 26 #include <linux/i2c.h> 27 #include <linux/hwmon.h> 28 #include <linux/err.h> 29 #include <linux/mutex.h> 30 31 32 /* Addresses to scan */ 33 static unsigned short normal_i2c[] = { 0x18, 0x19, 0x1a, 34 0x29, 0x2a, 0x2b, 35 0x4c, 0x4d, 0x4e, 36 I2C_CLIENT_END }; 37 38 /* Insmod parameters */ 39 I2C_CLIENT_INSMOD_8(adm1021, adm1023, max1617, max1617a, thmc10, lm84, gl523sm, mc1066); 40 41 /* adm1021 constants specified below */ 42 43 /* The adm1021 registers */ 44 /* Read-only */ 45 #define ADM1021_REG_TEMP 0x00 46 #define ADM1021_REG_REMOTE_TEMP 0x01 47 #define ADM1021_REG_STATUS 0x02 48 #define ADM1021_REG_MAN_ID 0x0FE /* 0x41 = AMD, 0x49 = TI, 0x4D = Maxim, 0x23 = Genesys , 0x54 = Onsemi*/ 49 #define ADM1021_REG_DEV_ID 0x0FF /* ADM1021 = 0x0X, ADM1023 = 0x3X */ 50 #define ADM1021_REG_DIE_CODE 0x0FF /* MAX1617A */ 51 /* These use different addresses for reading/writing */ 52 #define ADM1021_REG_CONFIG_R 0x03 53 #define ADM1021_REG_CONFIG_W 0x09 54 #define ADM1021_REG_CONV_RATE_R 0x04 55 #define ADM1021_REG_CONV_RATE_W 0x0A 56 /* These are for the ADM1023's additional precision on the remote temp sensor */ 57 #define ADM1021_REG_REM_TEMP_PREC 0x010 58 #define ADM1021_REG_REM_OFFSET 0x011 59 #define ADM1021_REG_REM_OFFSET_PREC 0x012 60 #define ADM1021_REG_REM_TOS_PREC 0x013 61 #define ADM1021_REG_REM_THYST_PREC 0x014 62 /* limits */ 63 #define ADM1021_REG_TOS_R 0x05 64 #define ADM1021_REG_TOS_W 0x0B 65 #define ADM1021_REG_REMOTE_TOS_R 0x07 66 #define ADM1021_REG_REMOTE_TOS_W 0x0D 67 #define ADM1021_REG_THYST_R 0x06 68 #define ADM1021_REG_THYST_W 0x0C 69 #define ADM1021_REG_REMOTE_THYST_R 0x08 70 #define ADM1021_REG_REMOTE_THYST_W 0x0E 71 /* write-only */ 72 #define ADM1021_REG_ONESHOT 0x0F 73 74 75 /* Conversions. Rounding and limit checking is only done on the TO_REG 76 variants. Note that you should be a bit careful with which arguments 77 these macros are called: arguments may be evaluated more than once. 78 Fixing this is just not worth it. */ 79 /* Conversions note: 1021 uses normal integer signed-byte format*/ 80 #define TEMP_FROM_REG(val) (val > 127 ? (val-256)*1000 : val*1000) 81 #define TEMP_TO_REG(val) (SENSORS_LIMIT((val < 0 ? (val/1000)+256 : val/1000),0,255)) 82 83 /* Initial values */ 84 85 /* Note: Even though I left the low and high limits named os and hyst, 86 they don't quite work like a thermostat the way the LM75 does. I.e., 87 a lower temp than THYST actually triggers an alarm instead of 88 clearing it. Weird, ey? --Phil */ 89 90 /* Each client has this additional data */ 91 struct adm1021_data { 92 struct i2c_client client; 93 struct class_device *class_dev; 94 enum chips type; 95 96 struct mutex update_lock; 97 char valid; /* !=0 if following fields are valid */ 98 unsigned long last_updated; /* In jiffies */ 99 100 u8 temp_max; /* Register values */ 101 u8 temp_hyst; 102 u8 temp_input; 103 u8 remote_temp_max; 104 u8 remote_temp_hyst; 105 u8 remote_temp_input; 106 u8 alarms; 107 /* Special values for ADM1023 only */ 108 u8 remote_temp_prec; 109 u8 remote_temp_os_prec; 110 u8 remote_temp_hyst_prec; 111 u8 remote_temp_offset; 112 u8 remote_temp_offset_prec; 113 }; 114 115 static int adm1021_attach_adapter(struct i2c_adapter *adapter); 116 static int adm1021_detect(struct i2c_adapter *adapter, int address, int kind); 117 static void adm1021_init_client(struct i2c_client *client); 118 static int adm1021_detach_client(struct i2c_client *client); 119 static int adm1021_read_value(struct i2c_client *client, u8 reg); 120 static int adm1021_write_value(struct i2c_client *client, u8 reg, 121 u16 value); 122 static struct adm1021_data *adm1021_update_device(struct device *dev); 123 124 /* (amalysh) read only mode, otherwise any limit's writing confuse BIOS */ 125 static int read_only; 126 127 128 /* This is the driver that will be inserted */ 129 static struct i2c_driver adm1021_driver = { 130 .driver = { 131 .name = "adm1021", 132 }, 133 .id = I2C_DRIVERID_ADM1021, 134 .attach_adapter = adm1021_attach_adapter, 135 .detach_client = adm1021_detach_client, 136 }; 137 138 #define show(value) \ 139 static ssize_t show_##value(struct device *dev, struct device_attribute *attr, char *buf) \ 140 { \ 141 struct adm1021_data *data = adm1021_update_device(dev); \ 142 return sprintf(buf, "%d\n", TEMP_FROM_REG(data->value)); \ 143 } 144 show(temp_max); 145 show(temp_hyst); 146 show(temp_input); 147 show(remote_temp_max); 148 show(remote_temp_hyst); 149 show(remote_temp_input); 150 151 #define show2(value) \ 152 static ssize_t show_##value(struct device *dev, struct device_attribute *attr, char *buf) \ 153 { \ 154 struct adm1021_data *data = adm1021_update_device(dev); \ 155 return sprintf(buf, "%d\n", data->value); \ 156 } 157 show2(alarms); 158 159 #define set(value, reg) \ 160 static ssize_t set_##value(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) \ 161 { \ 162 struct i2c_client *client = to_i2c_client(dev); \ 163 struct adm1021_data *data = i2c_get_clientdata(client); \ 164 int temp = simple_strtoul(buf, NULL, 10); \ 165 \ 166 mutex_lock(&data->update_lock); \ 167 data->value = TEMP_TO_REG(temp); \ 168 adm1021_write_value(client, reg, data->value); \ 169 mutex_unlock(&data->update_lock); \ 170 return count; \ 171 } 172 set(temp_max, ADM1021_REG_TOS_W); 173 set(temp_hyst, ADM1021_REG_THYST_W); 174 set(remote_temp_max, ADM1021_REG_REMOTE_TOS_W); 175 set(remote_temp_hyst, ADM1021_REG_REMOTE_THYST_W); 176 177 static DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO, show_temp_max, set_temp_max); 178 static DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO, show_temp_hyst, set_temp_hyst); 179 static DEVICE_ATTR(temp1_input, S_IRUGO, show_temp_input, NULL); 180 static DEVICE_ATTR(temp2_max, S_IWUSR | S_IRUGO, show_remote_temp_max, set_remote_temp_max); 181 static DEVICE_ATTR(temp2_min, S_IWUSR | S_IRUGO, show_remote_temp_hyst, set_remote_temp_hyst); 182 static DEVICE_ATTR(temp2_input, S_IRUGO, show_remote_temp_input, NULL); 183 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL); 184 185 186 static int adm1021_attach_adapter(struct i2c_adapter *adapter) 187 { 188 if (!(adapter->class & I2C_CLASS_HWMON)) 189 return 0; 190 return i2c_probe(adapter, &addr_data, adm1021_detect); 191 } 192 193 static int adm1021_detect(struct i2c_adapter *adapter, int address, int kind) 194 { 195 int i; 196 struct i2c_client *new_client; 197 struct adm1021_data *data; 198 int err = 0; 199 const char *type_name = ""; 200 201 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) 202 goto error0; 203 204 /* OK. For now, we presume we have a valid client. We now create the 205 client structure, even though we cannot fill it completely yet. 206 But it allows us to access adm1021_{read,write}_value. */ 207 208 if (!(data = kzalloc(sizeof(struct adm1021_data), GFP_KERNEL))) { 209 err = -ENOMEM; 210 goto error0; 211 } 212 213 new_client = &data->client; 214 i2c_set_clientdata(new_client, data); 215 new_client->addr = address; 216 new_client->adapter = adapter; 217 new_client->driver = &adm1021_driver; 218 new_client->flags = 0; 219 220 /* Now, we do the remaining detection. */ 221 if (kind < 0) { 222 if ((adm1021_read_value(new_client, ADM1021_REG_STATUS) & 0x03) != 0x00 223 || (adm1021_read_value(new_client, ADM1021_REG_CONFIG_R) & 0x3F) != 0x00 224 || (adm1021_read_value(new_client, ADM1021_REG_CONV_RATE_R) & 0xF8) != 0x00) { 225 err = -ENODEV; 226 goto error1; 227 } 228 } 229 230 /* Determine the chip type. */ 231 if (kind <= 0) { 232 i = adm1021_read_value(new_client, ADM1021_REG_MAN_ID); 233 if (i == 0x41) 234 if ((adm1021_read_value(new_client, ADM1021_REG_DEV_ID) & 0x0F0) == 0x030) 235 kind = adm1023; 236 else 237 kind = adm1021; 238 else if (i == 0x49) 239 kind = thmc10; 240 else if (i == 0x23) 241 kind = gl523sm; 242 else if ((i == 0x4d) && 243 (adm1021_read_value(new_client, ADM1021_REG_DEV_ID) == 0x01)) 244 kind = max1617a; 245 else if (i == 0x54) 246 kind = mc1066; 247 /* LM84 Mfr ID in a different place, and it has more unused bits */ 248 else if (adm1021_read_value(new_client, ADM1021_REG_CONV_RATE_R) == 0x00 249 && (kind == 0 /* skip extra detection */ 250 || ((adm1021_read_value(new_client, ADM1021_REG_CONFIG_R) & 0x7F) == 0x00 251 && (adm1021_read_value(new_client, ADM1021_REG_STATUS) & 0xAB) == 0x00))) 252 kind = lm84; 253 else 254 kind = max1617; 255 } 256 257 if (kind == max1617) { 258 type_name = "max1617"; 259 } else if (kind == max1617a) { 260 type_name = "max1617a"; 261 } else if (kind == adm1021) { 262 type_name = "adm1021"; 263 } else if (kind == adm1023) { 264 type_name = "adm1023"; 265 } else if (kind == thmc10) { 266 type_name = "thmc10"; 267 } else if (kind == lm84) { 268 type_name = "lm84"; 269 } else if (kind == gl523sm) { 270 type_name = "gl523sm"; 271 } else if (kind == mc1066) { 272 type_name = "mc1066"; 273 } 274 275 /* Fill in the remaining client fields and put it into the global list */ 276 strlcpy(new_client->name, type_name, I2C_NAME_SIZE); 277 data->type = kind; 278 data->valid = 0; 279 mutex_init(&data->update_lock); 280 281 /* Tell the I2C layer a new client has arrived */ 282 if ((err = i2c_attach_client(new_client))) 283 goto error1; 284 285 /* Initialize the ADM1021 chip */ 286 if (kind != lm84) 287 adm1021_init_client(new_client); 288 289 /* Register sysfs hooks */ 290 data->class_dev = hwmon_device_register(&new_client->dev); 291 if (IS_ERR(data->class_dev)) { 292 err = PTR_ERR(data->class_dev); 293 goto error2; 294 } 295 296 device_create_file(&new_client->dev, &dev_attr_temp1_max); 297 device_create_file(&new_client->dev, &dev_attr_temp1_min); 298 device_create_file(&new_client->dev, &dev_attr_temp1_input); 299 device_create_file(&new_client->dev, &dev_attr_temp2_max); 300 device_create_file(&new_client->dev, &dev_attr_temp2_min); 301 device_create_file(&new_client->dev, &dev_attr_temp2_input); 302 device_create_file(&new_client->dev, &dev_attr_alarms); 303 304 return 0; 305 306 error2: 307 i2c_detach_client(new_client); 308 error1: 309 kfree(data); 310 error0: 311 return err; 312 } 313 314 static void adm1021_init_client(struct i2c_client *client) 315 { 316 /* Enable ADC and disable suspend mode */ 317 adm1021_write_value(client, ADM1021_REG_CONFIG_W, 318 adm1021_read_value(client, ADM1021_REG_CONFIG_R) & 0xBF); 319 /* Set Conversion rate to 1/sec (this can be tinkered with) */ 320 adm1021_write_value(client, ADM1021_REG_CONV_RATE_W, 0x04); 321 } 322 323 static int adm1021_detach_client(struct i2c_client *client) 324 { 325 struct adm1021_data *data = i2c_get_clientdata(client); 326 int err; 327 328 hwmon_device_unregister(data->class_dev); 329 330 if ((err = i2c_detach_client(client))) 331 return err; 332 333 kfree(data); 334 return 0; 335 } 336 337 /* All registers are byte-sized */ 338 static int adm1021_read_value(struct i2c_client *client, u8 reg) 339 { 340 return i2c_smbus_read_byte_data(client, reg); 341 } 342 343 static int adm1021_write_value(struct i2c_client *client, u8 reg, u16 value) 344 { 345 if (!read_only) 346 return i2c_smbus_write_byte_data(client, reg, value); 347 return 0; 348 } 349 350 static struct adm1021_data *adm1021_update_device(struct device *dev) 351 { 352 struct i2c_client *client = to_i2c_client(dev); 353 struct adm1021_data *data = i2c_get_clientdata(client); 354 355 mutex_lock(&data->update_lock); 356 357 if (time_after(jiffies, data->last_updated + HZ + HZ / 2) 358 || !data->valid) { 359 dev_dbg(&client->dev, "Starting adm1021 update\n"); 360 361 data->temp_input = adm1021_read_value(client, ADM1021_REG_TEMP); 362 data->temp_max = adm1021_read_value(client, ADM1021_REG_TOS_R); 363 data->temp_hyst = adm1021_read_value(client, ADM1021_REG_THYST_R); 364 data->remote_temp_input = adm1021_read_value(client, ADM1021_REG_REMOTE_TEMP); 365 data->remote_temp_max = adm1021_read_value(client, ADM1021_REG_REMOTE_TOS_R); 366 data->remote_temp_hyst = adm1021_read_value(client, ADM1021_REG_REMOTE_THYST_R); 367 data->alarms = adm1021_read_value(client, ADM1021_REG_STATUS) & 0x7c; 368 if (data->type == adm1023) { 369 data->remote_temp_prec = adm1021_read_value(client, ADM1021_REG_REM_TEMP_PREC); 370 data->remote_temp_os_prec = adm1021_read_value(client, ADM1021_REG_REM_TOS_PREC); 371 data->remote_temp_hyst_prec = adm1021_read_value(client, ADM1021_REG_REM_THYST_PREC); 372 data->remote_temp_offset = adm1021_read_value(client, ADM1021_REG_REM_OFFSET); 373 data->remote_temp_offset_prec = adm1021_read_value(client, ADM1021_REG_REM_OFFSET_PREC); 374 } 375 data->last_updated = jiffies; 376 data->valid = 1; 377 } 378 379 mutex_unlock(&data->update_lock); 380 381 return data; 382 } 383 384 static int __init sensors_adm1021_init(void) 385 { 386 return i2c_add_driver(&adm1021_driver); 387 } 388 389 static void __exit sensors_adm1021_exit(void) 390 { 391 i2c_del_driver(&adm1021_driver); 392 } 393 394 MODULE_AUTHOR ("Frodo Looijaard <frodol@dds.nl> and " 395 "Philip Edelbrock <phil@netroedge.com>"); 396 MODULE_DESCRIPTION("adm1021 driver"); 397 MODULE_LICENSE("GPL"); 398 399 module_param(read_only, bool, 0); 400 MODULE_PARM_DESC(read_only, "Don't set any values, read only mode"); 401 402 module_init(sensors_adm1021_init) 403 module_exit(sensors_adm1021_exit) 404