1 /* 2 w83792d.c - Part of lm_sensors, Linux kernel modules for hardware 3 monitoring 4 Copyright (C) 2004, 2005 Winbond Electronics Corp. 5 Chunhao Huang <DZShen@Winbond.com.tw>, 6 Rudolf Marek <r.marek@sh.cvut.cz> 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; either version 2 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program; if not, write to the Free Software 20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 21 22 Note: 23 1. This driver is only for 2.6 kernel, 2.4 kernel need a different driver. 24 2. This driver is only for Winbond W83792D C version device, there 25 are also some motherboards with B version W83792D device. The 26 calculation method to in6-in7(measured value, limits) is a little 27 different between C and B version. C or B version can be identified 28 by CR[0x49h]. 29 */ 30 31 /* 32 Supports following chips: 33 34 Chip #vin #fanin #pwm #temp wchipid vendid i2c ISA 35 w83792d 9 7 7 3 0x7a 0x5ca3 yes no 36 */ 37 38 #include <linux/config.h> 39 #include <linux/module.h> 40 #include <linux/init.h> 41 #include <linux/slab.h> 42 #include <linux/i2c.h> 43 #include <linux/hwmon.h> 44 #include <linux/hwmon-sysfs.h> 45 #include <linux/err.h> 46 47 /* Addresses to scan */ 48 static unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, 0x2f, I2C_CLIENT_END }; 49 50 /* Insmod parameters */ 51 I2C_CLIENT_INSMOD_1(w83792d); 52 I2C_CLIENT_MODULE_PARM(force_subclients, "List of subclient addresses: " 53 "{bus, clientaddr, subclientaddr1, subclientaddr2}"); 54 55 static int init; 56 module_param(init, bool, 0); 57 MODULE_PARM_DESC(init, "Set to one to force chip initialization"); 58 59 /* The W83792D registers */ 60 static const u8 W83792D_REG_IN[9] = { 61 0x20, /* Vcore A in DataSheet */ 62 0x21, /* Vcore B in DataSheet */ 63 0x22, /* VIN0 in DataSheet */ 64 0x23, /* VIN1 in DataSheet */ 65 0x24, /* VIN2 in DataSheet */ 66 0x25, /* VIN3 in DataSheet */ 67 0x26, /* 5VCC in DataSheet */ 68 0xB0, /* 5VSB in DataSheet */ 69 0xB1 /* VBAT in DataSheet */ 70 }; 71 #define W83792D_REG_LOW_BITS1 0x3E /* Low Bits I in DataSheet */ 72 #define W83792D_REG_LOW_BITS2 0x3F /* Low Bits II in DataSheet */ 73 static const u8 W83792D_REG_IN_MAX[9] = { 74 0x2B, /* Vcore A High Limit in DataSheet */ 75 0x2D, /* Vcore B High Limit in DataSheet */ 76 0x2F, /* VIN0 High Limit in DataSheet */ 77 0x31, /* VIN1 High Limit in DataSheet */ 78 0x33, /* VIN2 High Limit in DataSheet */ 79 0x35, /* VIN3 High Limit in DataSheet */ 80 0x37, /* 5VCC High Limit in DataSheet */ 81 0xB4, /* 5VSB High Limit in DataSheet */ 82 0xB6 /* VBAT High Limit in DataSheet */ 83 }; 84 static const u8 W83792D_REG_IN_MIN[9] = { 85 0x2C, /* Vcore A Low Limit in DataSheet */ 86 0x2E, /* Vcore B Low Limit in DataSheet */ 87 0x30, /* VIN0 Low Limit in DataSheet */ 88 0x32, /* VIN1 Low Limit in DataSheet */ 89 0x34, /* VIN2 Low Limit in DataSheet */ 90 0x36, /* VIN3 Low Limit in DataSheet */ 91 0x38, /* 5VCC Low Limit in DataSheet */ 92 0xB5, /* 5VSB Low Limit in DataSheet */ 93 0xB7 /* VBAT Low Limit in DataSheet */ 94 }; 95 static const u8 W83792D_REG_FAN[7] = { 96 0x28, /* FAN 1 Count in DataSheet */ 97 0x29, /* FAN 2 Count in DataSheet */ 98 0x2A, /* FAN 3 Count in DataSheet */ 99 0xB8, /* FAN 4 Count in DataSheet */ 100 0xB9, /* FAN 5 Count in DataSheet */ 101 0xBA, /* FAN 6 Count in DataSheet */ 102 0xBE /* FAN 7 Count in DataSheet */ 103 }; 104 static const u8 W83792D_REG_FAN_MIN[7] = { 105 0x3B, /* FAN 1 Count Low Limit in DataSheet */ 106 0x3C, /* FAN 2 Count Low Limit in DataSheet */ 107 0x3D, /* FAN 3 Count Low Limit in DataSheet */ 108 0xBB, /* FAN 4 Count Low Limit in DataSheet */ 109 0xBC, /* FAN 5 Count Low Limit in DataSheet */ 110 0xBD, /* FAN 6 Count Low Limit in DataSheet */ 111 0xBF /* FAN 7 Count Low Limit in DataSheet */ 112 }; 113 #define W83792D_REG_FAN_CFG 0x84 /* FAN Configuration in DataSheet */ 114 static const u8 W83792D_REG_FAN_DIV[4] = { 115 0x47, /* contains FAN2 and FAN1 Divisor */ 116 0x5B, /* contains FAN4 and FAN3 Divisor */ 117 0x5C, /* contains FAN6 and FAN5 Divisor */ 118 0x9E /* contains FAN7 Divisor. */ 119 }; 120 static const u8 W83792D_REG_PWM[7] = { 121 0x81, /* FAN 1 Duty Cycle, be used to control */ 122 0x83, /* FAN 2 Duty Cycle, be used to control */ 123 0x94, /* FAN 3 Duty Cycle, be used to control */ 124 0xA3, /* FAN 4 Duty Cycle, be used to control */ 125 0xA4, /* FAN 5 Duty Cycle, be used to control */ 126 0xA5, /* FAN 6 Duty Cycle, be used to control */ 127 0xA6 /* FAN 7 Duty Cycle, be used to control */ 128 }; 129 #define W83792D_REG_BANK 0x4E 130 #define W83792D_REG_TEMP2_CONFIG 0xC2 131 #define W83792D_REG_TEMP3_CONFIG 0xCA 132 133 static const u8 W83792D_REG_TEMP1[3] = { 134 0x27, /* TEMP 1 in DataSheet */ 135 0x39, /* TEMP 1 Over in DataSheet */ 136 0x3A, /* TEMP 1 Hyst in DataSheet */ 137 }; 138 139 static const u8 W83792D_REG_TEMP_ADD[2][6] = { 140 { 0xC0, /* TEMP 2 in DataSheet */ 141 0xC1, /* TEMP 2(0.5 deg) in DataSheet */ 142 0xC5, /* TEMP 2 Over High part in DataSheet */ 143 0xC6, /* TEMP 2 Over Low part in DataSheet */ 144 0xC3, /* TEMP 2 Thyst High part in DataSheet */ 145 0xC4 }, /* TEMP 2 Thyst Low part in DataSheet */ 146 { 0xC8, /* TEMP 3 in DataSheet */ 147 0xC9, /* TEMP 3(0.5 deg) in DataSheet */ 148 0xCD, /* TEMP 3 Over High part in DataSheet */ 149 0xCE, /* TEMP 3 Over Low part in DataSheet */ 150 0xCB, /* TEMP 3 Thyst High part in DataSheet */ 151 0xCC } /* TEMP 3 Thyst Low part in DataSheet */ 152 }; 153 154 static const u8 W83792D_REG_THERMAL[3] = { 155 0x85, /* SmartFanI: Fan1 target value */ 156 0x86, /* SmartFanI: Fan2 target value */ 157 0x96 /* SmartFanI: Fan3 target value */ 158 }; 159 160 static const u8 W83792D_REG_TOLERANCE[3] = { 161 0x87, /* (bit3-0)SmartFan Fan1 tolerance */ 162 0x87, /* (bit7-4)SmartFan Fan2 tolerance */ 163 0x97 /* (bit3-0)SmartFan Fan3 tolerance */ 164 }; 165 166 static const u8 W83792D_REG_POINTS[3][4] = { 167 { 0x85, /* SmartFanII: Fan1 temp point 1 */ 168 0xE3, /* SmartFanII: Fan1 temp point 2 */ 169 0xE4, /* SmartFanII: Fan1 temp point 3 */ 170 0xE5 }, /* SmartFanII: Fan1 temp point 4 */ 171 { 0x86, /* SmartFanII: Fan2 temp point 1 */ 172 0xE6, /* SmartFanII: Fan2 temp point 2 */ 173 0xE7, /* SmartFanII: Fan2 temp point 3 */ 174 0xE8 }, /* SmartFanII: Fan2 temp point 4 */ 175 { 0x96, /* SmartFanII: Fan3 temp point 1 */ 176 0xE9, /* SmartFanII: Fan3 temp point 2 */ 177 0xEA, /* SmartFanII: Fan3 temp point 3 */ 178 0xEB } /* SmartFanII: Fan3 temp point 4 */ 179 }; 180 181 static const u8 W83792D_REG_LEVELS[3][4] = { 182 { 0x88, /* (bit3-0) SmartFanII: Fan1 Non-Stop */ 183 0x88, /* (bit7-4) SmartFanII: Fan1 Level 1 */ 184 0xE0, /* (bit7-4) SmartFanII: Fan1 Level 2 */ 185 0xE0 }, /* (bit3-0) SmartFanII: Fan1 Level 3 */ 186 { 0x89, /* (bit3-0) SmartFanII: Fan2 Non-Stop */ 187 0x89, /* (bit7-4) SmartFanII: Fan2 Level 1 */ 188 0xE1, /* (bit7-4) SmartFanII: Fan2 Level 2 */ 189 0xE1 }, /* (bit3-0) SmartFanII: Fan2 Level 3 */ 190 { 0x98, /* (bit3-0) SmartFanII: Fan3 Non-Stop */ 191 0x98, /* (bit7-4) SmartFanII: Fan3 Level 1 */ 192 0xE2, /* (bit7-4) SmartFanII: Fan3 Level 2 */ 193 0xE2 } /* (bit3-0) SmartFanII: Fan3 Level 3 */ 194 }; 195 196 #define W83792D_REG_GPIO_EN 0x1A 197 #define W83792D_REG_CONFIG 0x40 198 #define W83792D_REG_VID_FANDIV 0x47 199 #define W83792D_REG_CHIPID 0x49 200 #define W83792D_REG_WCHIPID 0x58 201 #define W83792D_REG_CHIPMAN 0x4F 202 #define W83792D_REG_PIN 0x4B 203 #define W83792D_REG_I2C_SUBADDR 0x4A 204 205 #define W83792D_REG_ALARM1 0xA9 /* realtime status register1 */ 206 #define W83792D_REG_ALARM2 0xAA /* realtime status register2 */ 207 #define W83792D_REG_ALARM3 0xAB /* realtime status register3 */ 208 #define W83792D_REG_CHASSIS 0x42 /* Bit 5: Case Open status bit */ 209 #define W83792D_REG_CHASSIS_CLR 0x44 /* Bit 7: Case Open CLR_CHS/Reset bit */ 210 211 /* control in0/in1 's limit modifiability */ 212 #define W83792D_REG_VID_IN_B 0x17 213 214 #define W83792D_REG_VBAT 0x5D 215 #define W83792D_REG_I2C_ADDR 0x48 216 217 /* Conversions. Rounding and limit checking is only done on the TO_REG 218 variants. Note that you should be a bit careful with which arguments 219 these macros are called: arguments may be evaluated more than once. 220 Fixing this is just not worth it. */ 221 #define IN_FROM_REG(nr,val) (((nr)<=1)?(val*2): \ 222 ((((nr)==6)||((nr)==7))?(val*6):(val*4))) 223 #define IN_TO_REG(nr,val) (((nr)<=1)?(val/2): \ 224 ((((nr)==6)||((nr)==7))?(val/6):(val/4))) 225 226 static inline u8 227 FAN_TO_REG(long rpm, int div) 228 { 229 if (rpm == 0) 230 return 255; 231 rpm = SENSORS_LIMIT(rpm, 1, 1000000); 232 return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1, 254); 233 } 234 235 #define FAN_FROM_REG(val,div) ((val) == 0 ? -1 : \ 236 ((val) == 255 ? 0 : \ 237 1350000 / ((val) * (div)))) 238 239 /* for temp1 */ 240 #define TEMP1_TO_REG(val) (SENSORS_LIMIT(((val) < 0 ? (val)+0x100*1000 \ 241 : (val)) / 1000, 0, 0xff)) 242 #define TEMP1_FROM_REG(val) (((val) & 0x80 ? (val)-0x100 : (val)) * 1000) 243 /* for temp2 and temp3, because they need addtional resolution */ 244 #define TEMP_ADD_FROM_REG(val1, val2) \ 245 ((((val1) & 0x80 ? (val1)-0x100 \ 246 : (val1)) * 1000) + ((val2 & 0x80) ? 500 : 0)) 247 #define TEMP_ADD_TO_REG_HIGH(val) \ 248 (SENSORS_LIMIT(((val) < 0 ? (val)+0x100*1000 \ 249 : (val)) / 1000, 0, 0xff)) 250 #define TEMP_ADD_TO_REG_LOW(val) ((val%1000) ? 0x80 : 0x00) 251 252 #define PWM_FROM_REG(val) (val) 253 #define PWM_TO_REG(val) (SENSORS_LIMIT((val),0,255)) 254 #define DIV_FROM_REG(val) (1 << (val)) 255 256 static inline u8 257 DIV_TO_REG(long val) 258 { 259 int i; 260 val = SENSORS_LIMIT(val, 1, 128) >> 1; 261 for (i = 0; i < 7; i++) { 262 if (val == 0) 263 break; 264 val >>= 1; 265 } 266 return ((u8) i); 267 } 268 269 struct w83792d_data { 270 struct i2c_client client; 271 struct class_device *class_dev; 272 struct semaphore lock; 273 enum chips type; 274 275 struct semaphore update_lock; 276 char valid; /* !=0 if following fields are valid */ 277 unsigned long last_updated; /* In jiffies */ 278 279 /* array of 2 pointers to subclients */ 280 struct i2c_client *lm75[2]; 281 282 u8 in[9]; /* Register value */ 283 u8 in_max[9]; /* Register value */ 284 u8 in_min[9]; /* Register value */ 285 u8 low_bits[2]; /* Additional resolution to voltage in0-6 */ 286 u8 fan[7]; /* Register value */ 287 u8 fan_min[7]; /* Register value */ 288 u8 temp1[3]; /* current, over, thyst */ 289 u8 temp_add[2][6]; /* Register value */ 290 u8 fan_div[7]; /* Register encoding, shifted right */ 291 u8 pwm[7]; /* We only consider the first 3 set of pwm, 292 although 792 chip has 7 set of pwm. */ 293 u8 pwmenable[3]; 294 u8 pwm_mode[7]; /* indicates PWM or DC mode: 1->PWM; 0->DC */ 295 u32 alarms; /* realtime status register encoding,combined */ 296 u8 chassis; /* Chassis status */ 297 u8 chassis_clear; /* CLR_CHS, clear chassis intrusion detection */ 298 u8 thermal_cruise[3]; /* Smart FanI: Fan1,2,3 target value */ 299 u8 tolerance[3]; /* Fan1,2,3 tolerance(Smart Fan I/II) */ 300 u8 sf2_points[3][4]; /* Smart FanII: Fan1,2,3 temperature points */ 301 u8 sf2_levels[3][4]; /* Smart FanII: Fan1,2,3 duty cycle levels */ 302 }; 303 304 static int w83792d_attach_adapter(struct i2c_adapter *adapter); 305 static int w83792d_detect(struct i2c_adapter *adapter, int address, int kind); 306 static int w83792d_detach_client(struct i2c_client *client); 307 308 static int w83792d_read_value(struct i2c_client *client, u8 register); 309 static int w83792d_write_value(struct i2c_client *client, u8 register, 310 u8 value); 311 static struct w83792d_data *w83792d_update_device(struct device *dev); 312 313 #ifdef DEBUG 314 static void w83792d_print_debug(struct w83792d_data *data, struct device *dev); 315 #endif 316 317 static void w83792d_init_client(struct i2c_client *client); 318 319 static struct i2c_driver w83792d_driver = { 320 .owner = THIS_MODULE, 321 .name = "w83792d", 322 .flags = I2C_DF_NOTIFY, 323 .attach_adapter = w83792d_attach_adapter, 324 .detach_client = w83792d_detach_client, 325 }; 326 327 static long in_count_from_reg(int nr, struct w83792d_data *data) 328 { 329 u16 vol_count = data->in[nr]; 330 u16 low_bits = 0; 331 vol_count = (vol_count << 2); 332 switch (nr) 333 { 334 case 0: /* vin0 */ 335 low_bits = (data->low_bits[0]) & 0x03; 336 break; 337 case 1: /* vin1 */ 338 low_bits = ((data->low_bits[0]) & 0x0c) >> 2; 339 break; 340 case 2: /* vin2 */ 341 low_bits = ((data->low_bits[0]) & 0x30) >> 4; 342 break; 343 case 3: /* vin3 */ 344 low_bits = ((data->low_bits[0]) & 0xc0) >> 6; 345 break; 346 case 4: /* vin4 */ 347 low_bits = (data->low_bits[1]) & 0x03; 348 break; 349 case 5: /* vin5 */ 350 low_bits = ((data->low_bits[1]) & 0x0c) >> 2; 351 break; 352 case 6: /* vin6 */ 353 low_bits = ((data->low_bits[1]) & 0x30) >> 4; 354 default: 355 break; 356 } 357 vol_count = vol_count | low_bits; 358 return vol_count; 359 } 360 361 /* following are the sysfs callback functions */ 362 static ssize_t show_in(struct device *dev, struct device_attribute *attr, 363 char *buf) 364 { 365 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 366 int nr = sensor_attr->index; 367 struct w83792d_data *data = w83792d_update_device(dev); 368 return sprintf(buf,"%ld\n", IN_FROM_REG(nr,(in_count_from_reg(nr, data)))); 369 } 370 371 #define show_in_reg(reg) \ 372 static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \ 373 char *buf) \ 374 { \ 375 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \ 376 int nr = sensor_attr->index; \ 377 struct w83792d_data *data = w83792d_update_device(dev); \ 378 return sprintf(buf,"%ld\n", (long)(IN_FROM_REG(nr, (data->reg[nr])*4))); \ 379 } 380 381 show_in_reg(in_min); 382 show_in_reg(in_max); 383 384 #define store_in_reg(REG, reg) \ 385 static ssize_t store_in_##reg (struct device *dev, \ 386 struct device_attribute *attr, \ 387 const char *buf, size_t count) \ 388 { \ 389 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \ 390 int nr = sensor_attr->index; \ 391 struct i2c_client *client = to_i2c_client(dev); \ 392 struct w83792d_data *data = i2c_get_clientdata(client); \ 393 u32 val; \ 394 \ 395 val = simple_strtoul(buf, NULL, 10); \ 396 data->in_##reg[nr] = SENSORS_LIMIT(IN_TO_REG(nr, val)/4, 0, 255); \ 397 w83792d_write_value(client, W83792D_REG_IN_##REG[nr], data->in_##reg[nr]); \ 398 \ 399 return count; \ 400 } 401 store_in_reg(MIN, min); 402 store_in_reg(MAX, max); 403 404 #define sysfs_in_reg(offset) \ 405 static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO, show_in, \ 406 NULL, offset); \ 407 static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR, \ 408 show_in_min, store_in_min, offset); \ 409 static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR, \ 410 show_in_max, store_in_max, offset); 411 412 sysfs_in_reg(0); 413 sysfs_in_reg(1); 414 sysfs_in_reg(2); 415 sysfs_in_reg(3); 416 sysfs_in_reg(4); 417 sysfs_in_reg(5); 418 sysfs_in_reg(6); 419 sysfs_in_reg(7); 420 sysfs_in_reg(8); 421 422 #define device_create_file_in(client, offset) \ 423 do { \ 424 device_create_file(&client->dev, &sensor_dev_attr_in##offset##_input.dev_attr); \ 425 device_create_file(&client->dev, &sensor_dev_attr_in##offset##_max.dev_attr); \ 426 device_create_file(&client->dev, &sensor_dev_attr_in##offset##_min.dev_attr); \ 427 } while (0) 428 429 #define show_fan_reg(reg) \ 430 static ssize_t show_##reg (struct device *dev, struct device_attribute *attr, \ 431 char *buf) \ 432 { \ 433 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); \ 434 int nr = sensor_attr->index - 1; \ 435 struct w83792d_data *data = w83792d_update_device(dev); \ 436 return sprintf(buf,"%d\n", \ 437 FAN_FROM_REG(data->reg[nr], DIV_FROM_REG(data->fan_div[nr]))); \ 438 } 439 440 show_fan_reg(fan); 441 show_fan_reg(fan_min); 442 443 static ssize_t 444 store_fan_min(struct device *dev, struct device_attribute *attr, 445 const char *buf, size_t count) 446 { 447 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 448 int nr = sensor_attr->index - 1; 449 struct i2c_client *client = to_i2c_client(dev); 450 struct w83792d_data *data = i2c_get_clientdata(client); 451 u32 val; 452 453 val = simple_strtoul(buf, NULL, 10); 454 data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr])); 455 w83792d_write_value(client, W83792D_REG_FAN_MIN[nr], 456 data->fan_min[nr]); 457 458 return count; 459 } 460 461 static ssize_t 462 show_fan_div(struct device *dev, struct device_attribute *attr, 463 char *buf) 464 { 465 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 466 int nr = sensor_attr->index; 467 struct w83792d_data *data = w83792d_update_device(dev); 468 return sprintf(buf, "%u\n", DIV_FROM_REG(data->fan_div[nr - 1])); 469 } 470 471 /* Note: we save and restore the fan minimum here, because its value is 472 determined in part by the fan divisor. This follows the principle of 473 least suprise; the user doesn't expect the fan minimum to change just 474 because the divisor changed. */ 475 static ssize_t 476 store_fan_div(struct device *dev, struct device_attribute *attr, 477 const char *buf, size_t count) 478 { 479 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 480 int nr = sensor_attr->index - 1; 481 struct i2c_client *client = to_i2c_client(dev); 482 struct w83792d_data *data = i2c_get_clientdata(client); 483 unsigned long min; 484 /*u8 reg;*/ 485 u8 fan_div_reg = 0; 486 u8 tmp_fan_div; 487 488 /* Save fan_min */ 489 min = FAN_FROM_REG(data->fan_min[nr], 490 DIV_FROM_REG(data->fan_div[nr])); 491 492 data->fan_div[nr] = DIV_TO_REG(simple_strtoul(buf, NULL, 10)); 493 494 fan_div_reg = w83792d_read_value(client, W83792D_REG_FAN_DIV[nr >> 1]); 495 fan_div_reg &= (nr & 0x01) ? 0x8f : 0xf8; 496 tmp_fan_div = (nr & 0x01) ? (((data->fan_div[nr]) << 4) & 0x70) 497 : ((data->fan_div[nr]) & 0x07); 498 w83792d_write_value(client, W83792D_REG_FAN_DIV[nr >> 1], 499 fan_div_reg | tmp_fan_div); 500 501 /* Restore fan_min */ 502 data->fan_min[nr] = FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr])); 503 w83792d_write_value(client, W83792D_REG_FAN_MIN[nr], data->fan_min[nr]); 504 505 return count; 506 } 507 508 #define sysfs_fan(offset) \ 509 static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, show_fan, NULL, \ 510 offset); \ 511 static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \ 512 show_fan_div, store_fan_div, offset); \ 513 static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \ 514 show_fan_min, store_fan_min, offset); 515 516 sysfs_fan(1); 517 sysfs_fan(2); 518 sysfs_fan(3); 519 sysfs_fan(4); 520 sysfs_fan(5); 521 sysfs_fan(6); 522 sysfs_fan(7); 523 524 #define device_create_file_fan(client, offset) \ 525 do { \ 526 device_create_file(&client->dev, &sensor_dev_attr_fan##offset##_input.dev_attr); \ 527 device_create_file(&client->dev, &sensor_dev_attr_fan##offset##_div.dev_attr); \ 528 device_create_file(&client->dev, &sensor_dev_attr_fan##offset##_min.dev_attr); \ 529 } while (0) 530 531 532 /* read/write the temperature1, includes measured value and limits */ 533 534 static ssize_t show_temp1(struct device *dev, struct device_attribute *attr, 535 char *buf) 536 { 537 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 538 int nr = sensor_attr->index; 539 struct w83792d_data *data = w83792d_update_device(dev); 540 return sprintf(buf, "%d\n", TEMP1_FROM_REG(data->temp1[nr])); 541 } 542 543 static ssize_t store_temp1(struct device *dev, struct device_attribute *attr, 544 const char *buf, size_t count) 545 { 546 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 547 int nr = sensor_attr->index; 548 struct i2c_client *client = to_i2c_client(dev); 549 struct w83792d_data *data = i2c_get_clientdata(client); 550 s32 val; 551 552 val = simple_strtol(buf, NULL, 10); 553 554 data->temp1[nr] = TEMP1_TO_REG(val); 555 w83792d_write_value(client, W83792D_REG_TEMP1[nr], 556 data->temp1[nr]); 557 558 return count; 559 } 560 561 562 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp1, NULL, 0); 563 static SENSOR_DEVICE_ATTR(temp1_max, S_IRUGO | S_IWUSR, show_temp1, 564 store_temp1, 1); 565 static SENSOR_DEVICE_ATTR(temp1_max_hyst, S_IRUGO | S_IWUSR, show_temp1, 566 store_temp1, 2); 567 568 #define device_create_file_temp1(client) \ 569 do { \ 570 device_create_file(&client->dev, &sensor_dev_attr_temp1_input.dev_attr); \ 571 device_create_file(&client->dev, &sensor_dev_attr_temp1_max.dev_attr); \ 572 device_create_file(&client->dev, &sensor_dev_attr_temp1_max_hyst.dev_attr); \ 573 } while (0) 574 575 576 /* read/write the temperature2-3, includes measured value and limits */ 577 578 static ssize_t show_temp23(struct device *dev, struct device_attribute *attr, 579 char *buf) 580 { 581 struct sensor_device_attribute_2 *sensor_attr = to_sensor_dev_attr_2(attr); 582 int nr = sensor_attr->nr; 583 int index = sensor_attr->index; 584 struct w83792d_data *data = w83792d_update_device(dev); 585 return sprintf(buf,"%ld\n", 586 (long)TEMP_ADD_FROM_REG(data->temp_add[nr][index], 587 data->temp_add[nr][index+1])); 588 } 589 590 static ssize_t store_temp23(struct device *dev, struct device_attribute *attr, 591 const char *buf, size_t count) 592 { 593 struct sensor_device_attribute_2 *sensor_attr = to_sensor_dev_attr_2(attr); 594 int nr = sensor_attr->nr; 595 int index = sensor_attr->index; 596 struct i2c_client *client = to_i2c_client(dev); 597 struct w83792d_data *data = i2c_get_clientdata(client); 598 s32 val; 599 600 val = simple_strtol(buf, NULL, 10); 601 602 data->temp_add[nr][index] = TEMP_ADD_TO_REG_HIGH(val); 603 data->temp_add[nr][index+1] = TEMP_ADD_TO_REG_LOW(val); 604 w83792d_write_value(client, W83792D_REG_TEMP_ADD[nr][index], 605 data->temp_add[nr][index]); 606 w83792d_write_value(client, W83792D_REG_TEMP_ADD[nr][index+1], 607 data->temp_add[nr][index+1]); 608 609 return count; 610 } 611 612 #define sysfs_temp23(name,idx) \ 613 static SENSOR_DEVICE_ATTR_2(name##_input, S_IRUGO, show_temp23, NULL, \ 614 idx, 0); \ 615 static SENSOR_DEVICE_ATTR_2(name##_max, S_IRUGO | S_IWUSR, \ 616 show_temp23, store_temp23, idx, 2); \ 617 static SENSOR_DEVICE_ATTR_2(name##_max_hyst, S_IRUGO | S_IWUSR, \ 618 show_temp23, store_temp23, idx, 4); 619 620 sysfs_temp23(temp2,0) 621 sysfs_temp23(temp3,1) 622 623 #define device_create_file_temp_add(client, offset) \ 624 do { \ 625 device_create_file(&client->dev, &sensor_dev_attr_temp##offset##_input.dev_attr); \ 626 device_create_file(&client->dev, &sensor_dev_attr_temp##offset##_max.dev_attr); \ 627 device_create_file(&client->dev, \ 628 &sensor_dev_attr_temp##offset##_max_hyst.dev_attr); \ 629 } while (0) 630 631 632 /* get reatime status of all sensors items: voltage, temp, fan */ 633 static ssize_t 634 show_alarms_reg(struct device *dev, struct device_attribute *attr, char *buf) 635 { 636 struct w83792d_data *data = w83792d_update_device(dev); 637 return sprintf(buf, "%d\n", data->alarms); 638 } 639 640 static 641 DEVICE_ATTR(alarms, S_IRUGO, show_alarms_reg, NULL); 642 #define device_create_file_alarms(client) \ 643 device_create_file(&client->dev, &dev_attr_alarms); 644 645 646 647 static ssize_t 648 show_pwm(struct device *dev, struct device_attribute *attr, 649 char *buf) 650 { 651 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 652 int nr = sensor_attr->index; 653 struct w83792d_data *data = w83792d_update_device(dev); 654 return sprintf(buf, "%ld\n", (long) PWM_FROM_REG(data->pwm[nr-1])); 655 } 656 657 static ssize_t 658 show_pwmenable(struct device *dev, struct device_attribute *attr, 659 char *buf) 660 { 661 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 662 int nr = sensor_attr->index - 1; 663 struct w83792d_data *data = w83792d_update_device(dev); 664 long pwm_enable_tmp = 1; 665 666 switch (data->pwmenable[nr]) { 667 case 0: 668 pwm_enable_tmp = 1; /* manual mode */ 669 break; 670 case 1: 671 pwm_enable_tmp = 3; /*thermal cruise/Smart Fan I */ 672 break; 673 case 2: 674 pwm_enable_tmp = 2; /* Smart Fan II */ 675 break; 676 } 677 678 return sprintf(buf, "%ld\n", pwm_enable_tmp); 679 } 680 681 static ssize_t 682 store_pwm(struct device *dev, struct device_attribute *attr, 683 const char *buf, size_t count) 684 { 685 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 686 int nr = sensor_attr->index - 1; 687 struct i2c_client *client = to_i2c_client(dev); 688 struct w83792d_data *data = i2c_get_clientdata(client); 689 u32 val; 690 691 val = simple_strtoul(buf, NULL, 10); 692 data->pwm[nr] = PWM_TO_REG(val); 693 w83792d_write_value(client, W83792D_REG_PWM[nr], data->pwm[nr]); 694 695 return count; 696 } 697 698 static ssize_t 699 store_pwmenable(struct device *dev, struct device_attribute *attr, 700 const char *buf, size_t count) 701 { 702 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 703 int nr = sensor_attr->index - 1; 704 struct i2c_client *client = to_i2c_client(dev); 705 struct w83792d_data *data = i2c_get_clientdata(client); 706 u32 val; 707 u8 fan_cfg_tmp, cfg1_tmp, cfg2_tmp, cfg3_tmp, cfg4_tmp; 708 709 val = simple_strtoul(buf, NULL, 10); 710 switch (val) { 711 case 1: 712 data->pwmenable[nr] = 0; /* manual mode */ 713 break; 714 case 2: 715 data->pwmenable[nr] = 2; /* Smart Fan II */ 716 break; 717 case 3: 718 data->pwmenable[nr] = 1; /* thermal cruise/Smart Fan I */ 719 break; 720 default: 721 return -EINVAL; 722 } 723 cfg1_tmp = data->pwmenable[0]; 724 cfg2_tmp = (data->pwmenable[1]) << 2; 725 cfg3_tmp = (data->pwmenable[2]) << 4; 726 cfg4_tmp = w83792d_read_value(client,W83792D_REG_FAN_CFG) & 0xc0; 727 fan_cfg_tmp = ((cfg4_tmp | cfg3_tmp) | cfg2_tmp) | cfg1_tmp; 728 w83792d_write_value(client, W83792D_REG_FAN_CFG, fan_cfg_tmp); 729 730 return count; 731 } 732 733 #define sysfs_pwm(offset) \ 734 static SENSOR_DEVICE_ATTR(pwm##offset, S_IRUGO | S_IWUSR, \ 735 show_pwm, store_pwm, offset); \ 736 static SENSOR_DEVICE_ATTR(pwm##offset##_enable, S_IRUGO | S_IWUSR, \ 737 show_pwmenable, store_pwmenable, offset); \ 738 739 sysfs_pwm(1); 740 sysfs_pwm(2); 741 sysfs_pwm(3); 742 743 744 #define device_create_file_pwm(client, offset) \ 745 do { \ 746 device_create_file(&client->dev, &sensor_dev_attr_pwm##offset.dev_attr); \ 747 } while (0) 748 749 #define device_create_file_pwmenable(client, offset) \ 750 do { \ 751 device_create_file(&client->dev, &sensor_dev_attr_pwm##offset##_enable.dev_attr); \ 752 } while (0) 753 754 755 static ssize_t 756 show_pwm_mode(struct device *dev, struct device_attribute *attr, 757 char *buf) 758 { 759 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 760 int nr = sensor_attr->index; 761 struct w83792d_data *data = w83792d_update_device(dev); 762 return sprintf(buf, "%d\n", data->pwm_mode[nr-1]); 763 } 764 765 static ssize_t 766 store_pwm_mode(struct device *dev, struct device_attribute *attr, 767 const char *buf, size_t count) 768 { 769 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 770 int nr = sensor_attr->index - 1; 771 struct i2c_client *client = to_i2c_client(dev); 772 struct w83792d_data *data = i2c_get_clientdata(client); 773 u32 val; 774 u8 pwm_mode_mask = 0; 775 776 val = simple_strtoul(buf, NULL, 10); 777 data->pwm_mode[nr] = SENSORS_LIMIT(val, 0, 1); 778 pwm_mode_mask = w83792d_read_value(client, 779 W83792D_REG_PWM[nr]) & 0x7f; 780 w83792d_write_value(client, W83792D_REG_PWM[nr], 781 ((data->pwm_mode[nr]) << 7) | pwm_mode_mask); 782 783 return count; 784 } 785 786 #define sysfs_pwm_mode(offset) \ 787 static SENSOR_DEVICE_ATTR(pwm##offset##_mode, S_IRUGO | S_IWUSR, \ 788 show_pwm_mode, store_pwm_mode, offset); 789 790 sysfs_pwm_mode(1); 791 sysfs_pwm_mode(2); 792 sysfs_pwm_mode(3); 793 794 #define device_create_file_pwm_mode(client, offset) \ 795 do { \ 796 device_create_file(&client->dev, &sensor_dev_attr_pwm##offset##_mode.dev_attr); \ 797 } while (0) 798 799 800 static ssize_t 801 show_regs_chassis(struct device *dev, struct device_attribute *attr, 802 char *buf) 803 { 804 struct w83792d_data *data = w83792d_update_device(dev); 805 return sprintf(buf, "%d\n", data->chassis); 806 } 807 808 static DEVICE_ATTR(chassis, S_IRUGO, show_regs_chassis, NULL); 809 810 #define device_create_file_chassis(client) \ 811 do { \ 812 device_create_file(&client->dev, &dev_attr_chassis); \ 813 } while (0) 814 815 816 static ssize_t 817 show_chassis_clear(struct device *dev, struct device_attribute *attr, char *buf) 818 { 819 struct w83792d_data *data = w83792d_update_device(dev); 820 return sprintf(buf, "%d\n", data->chassis_clear); 821 } 822 823 static ssize_t 824 store_chassis_clear(struct device *dev, struct device_attribute *attr, 825 const char *buf, size_t count) 826 { 827 struct i2c_client *client = to_i2c_client(dev); 828 struct w83792d_data *data = i2c_get_clientdata(client); 829 u32 val; 830 u8 temp1 = 0, temp2 = 0; 831 832 val = simple_strtoul(buf, NULL, 10); 833 834 data->chassis_clear = SENSORS_LIMIT(val, 0 ,1); 835 temp1 = ((data->chassis_clear) << 7) & 0x80; 836 temp2 = w83792d_read_value(client, 837 W83792D_REG_CHASSIS_CLR) & 0x7f; 838 w83792d_write_value(client, W83792D_REG_CHASSIS_CLR, temp1 | temp2); 839 840 return count; 841 } 842 843 static DEVICE_ATTR(chassis_clear, S_IRUGO | S_IWUSR, 844 show_chassis_clear, store_chassis_clear); 845 846 #define device_create_file_chassis_clear(client) \ 847 do { \ 848 device_create_file(&client->dev, &dev_attr_chassis_clear); \ 849 } while (0) 850 851 852 853 /* For Smart Fan I / Thermal Cruise */ 854 static ssize_t 855 show_thermal_cruise(struct device *dev, struct device_attribute *attr, 856 char *buf) 857 { 858 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 859 int nr = sensor_attr->index; 860 struct w83792d_data *data = w83792d_update_device(dev); 861 return sprintf(buf, "%ld\n", (long)data->thermal_cruise[nr-1]); 862 } 863 864 static ssize_t 865 store_thermal_cruise(struct device *dev, struct device_attribute *attr, 866 const char *buf, size_t count) 867 { 868 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 869 int nr = sensor_attr->index - 1; 870 struct i2c_client *client = to_i2c_client(dev); 871 struct w83792d_data *data = i2c_get_clientdata(client); 872 u32 val; 873 u8 target_tmp=0, target_mask=0; 874 875 val = simple_strtoul(buf, NULL, 10); 876 target_tmp = val; 877 target_tmp = target_tmp & 0x7f; 878 target_mask = w83792d_read_value(client, W83792D_REG_THERMAL[nr]) & 0x80; 879 data->thermal_cruise[nr] = SENSORS_LIMIT(target_tmp, 0, 255); 880 w83792d_write_value(client, W83792D_REG_THERMAL[nr], 881 (data->thermal_cruise[nr]) | target_mask); 882 883 return count; 884 } 885 886 #define sysfs_thermal_cruise(offset) \ 887 static SENSOR_DEVICE_ATTR(thermal_cruise##offset, S_IRUGO | S_IWUSR, \ 888 show_thermal_cruise, store_thermal_cruise, offset); 889 890 sysfs_thermal_cruise(1); 891 sysfs_thermal_cruise(2); 892 sysfs_thermal_cruise(3); 893 894 #define device_create_file_thermal_cruise(client, offset) \ 895 do { \ 896 device_create_file(&client->dev, \ 897 &sensor_dev_attr_thermal_cruise##offset.dev_attr); \ 898 } while (0) 899 900 901 /* For Smart Fan I/Thermal Cruise and Smart Fan II */ 902 static ssize_t 903 show_tolerance(struct device *dev, struct device_attribute *attr, 904 char *buf) 905 { 906 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 907 int nr = sensor_attr->index; 908 struct w83792d_data *data = w83792d_update_device(dev); 909 return sprintf(buf, "%ld\n", (long)data->tolerance[nr-1]); 910 } 911 912 static ssize_t 913 store_tolerance(struct device *dev, struct device_attribute *attr, 914 const char *buf, size_t count) 915 { 916 struct sensor_device_attribute *sensor_attr = to_sensor_dev_attr(attr); 917 int nr = sensor_attr->index - 1; 918 struct i2c_client *client = to_i2c_client(dev); 919 struct w83792d_data *data = i2c_get_clientdata(client); 920 u32 val; 921 u8 tol_tmp, tol_mask; 922 923 val = simple_strtoul(buf, NULL, 10); 924 tol_mask = w83792d_read_value(client, 925 W83792D_REG_TOLERANCE[nr]) & ((nr == 1) ? 0x0f : 0xf0); 926 tol_tmp = SENSORS_LIMIT(val, 0, 15); 927 tol_tmp &= 0x0f; 928 data->tolerance[nr] = tol_tmp; 929 if (nr == 1) { 930 tol_tmp <<= 4; 931 } 932 w83792d_write_value(client, W83792D_REG_TOLERANCE[nr], 933 tol_mask | tol_tmp); 934 935 return count; 936 } 937 938 #define sysfs_tolerance(offset) \ 939 static SENSOR_DEVICE_ATTR(tolerance##offset, S_IRUGO | S_IWUSR, \ 940 show_tolerance, store_tolerance, offset); 941 942 sysfs_tolerance(1); 943 sysfs_tolerance(2); 944 sysfs_tolerance(3); 945 946 #define device_create_file_tolerance(client, offset) \ 947 do { \ 948 device_create_file(&client->dev, &sensor_dev_attr_tolerance##offset.dev_attr); \ 949 } while (0) 950 951 952 /* For Smart Fan II */ 953 static ssize_t 954 show_sf2_point(struct device *dev, struct device_attribute *attr, 955 char *buf) 956 { 957 struct sensor_device_attribute_2 *sensor_attr = to_sensor_dev_attr_2(attr); 958 int nr = sensor_attr->nr; 959 int index = sensor_attr->index; 960 struct w83792d_data *data = w83792d_update_device(dev); 961 return sprintf(buf, "%ld\n", (long)data->sf2_points[index-1][nr-1]); 962 } 963 964 static ssize_t 965 store_sf2_point(struct device *dev, struct device_attribute *attr, 966 const char *buf, size_t count) 967 { 968 struct sensor_device_attribute_2 *sensor_attr = to_sensor_dev_attr_2(attr); 969 int nr = sensor_attr->nr - 1; 970 int index = sensor_attr->index - 1; 971 struct i2c_client *client = to_i2c_client(dev); 972 struct w83792d_data *data = i2c_get_clientdata(client); 973 u32 val; 974 u8 mask_tmp = 0; 975 976 val = simple_strtoul(buf, NULL, 10); 977 data->sf2_points[index][nr] = SENSORS_LIMIT(val, 0, 127); 978 mask_tmp = w83792d_read_value(client, 979 W83792D_REG_POINTS[index][nr]) & 0x80; 980 w83792d_write_value(client, W83792D_REG_POINTS[index][nr], 981 mask_tmp|data->sf2_points[index][nr]); 982 983 return count; 984 } 985 986 #define sysfs_sf2_point(offset, index) \ 987 static SENSOR_DEVICE_ATTR_2(sf2_point##offset##_fan##index, S_IRUGO | S_IWUSR, \ 988 show_sf2_point, store_sf2_point, offset, index); 989 990 sysfs_sf2_point(1, 1); /* Fan1 */ 991 sysfs_sf2_point(2, 1); /* Fan1 */ 992 sysfs_sf2_point(3, 1); /* Fan1 */ 993 sysfs_sf2_point(4, 1); /* Fan1 */ 994 sysfs_sf2_point(1, 2); /* Fan2 */ 995 sysfs_sf2_point(2, 2); /* Fan2 */ 996 sysfs_sf2_point(3, 2); /* Fan2 */ 997 sysfs_sf2_point(4, 2); /* Fan2 */ 998 sysfs_sf2_point(1, 3); /* Fan3 */ 999 sysfs_sf2_point(2, 3); /* Fan3 */ 1000 sysfs_sf2_point(3, 3); /* Fan3 */ 1001 sysfs_sf2_point(4, 3); /* Fan3 */ 1002 1003 #define device_create_file_sf2_point(client, offset, index) \ 1004 do { \ 1005 device_create_file(&client->dev, \ 1006 &sensor_dev_attr_sf2_point##offset##_fan##index.dev_attr); \ 1007 } while (0) 1008 1009 1010 static ssize_t 1011 show_sf2_level(struct device *dev, struct device_attribute *attr, 1012 char *buf) 1013 { 1014 struct sensor_device_attribute_2 *sensor_attr = to_sensor_dev_attr_2(attr); 1015 int nr = sensor_attr->nr; 1016 int index = sensor_attr->index; 1017 struct w83792d_data *data = w83792d_update_device(dev); 1018 return sprintf(buf, "%d\n", 1019 (((data->sf2_levels[index-1][nr]) * 100) / 15)); 1020 } 1021 1022 static ssize_t 1023 store_sf2_level(struct device *dev, struct device_attribute *attr, 1024 const char *buf, size_t count) 1025 { 1026 struct sensor_device_attribute_2 *sensor_attr = to_sensor_dev_attr_2(attr); 1027 int nr = sensor_attr->nr; 1028 int index = sensor_attr->index - 1; 1029 struct i2c_client *client = to_i2c_client(dev); 1030 struct w83792d_data *data = i2c_get_clientdata(client); 1031 u32 val; 1032 u8 mask_tmp=0, level_tmp=0; 1033 1034 val = simple_strtoul(buf, NULL, 10); 1035 data->sf2_levels[index][nr] = SENSORS_LIMIT((val * 15) / 100, 0, 15); 1036 mask_tmp = w83792d_read_value(client, W83792D_REG_LEVELS[index][nr]) 1037 & ((nr==3) ? 0xf0 : 0x0f); 1038 if (nr==3) { 1039 level_tmp = data->sf2_levels[index][nr]; 1040 } else { 1041 level_tmp = data->sf2_levels[index][nr] << 4; 1042 } 1043 w83792d_write_value(client, W83792D_REG_LEVELS[index][nr], level_tmp | mask_tmp); 1044 1045 return count; 1046 } 1047 1048 #define sysfs_sf2_level(offset, index) \ 1049 static SENSOR_DEVICE_ATTR_2(sf2_level##offset##_fan##index, S_IRUGO | S_IWUSR, \ 1050 show_sf2_level, store_sf2_level, offset, index); 1051 1052 sysfs_sf2_level(1, 1); /* Fan1 */ 1053 sysfs_sf2_level(2, 1); /* Fan1 */ 1054 sysfs_sf2_level(3, 1); /* Fan1 */ 1055 sysfs_sf2_level(1, 2); /* Fan2 */ 1056 sysfs_sf2_level(2, 2); /* Fan2 */ 1057 sysfs_sf2_level(3, 2); /* Fan2 */ 1058 sysfs_sf2_level(1, 3); /* Fan3 */ 1059 sysfs_sf2_level(2, 3); /* Fan3 */ 1060 sysfs_sf2_level(3, 3); /* Fan3 */ 1061 1062 #define device_create_file_sf2_level(client, offset, index) \ 1063 do { \ 1064 device_create_file(&client->dev, \ 1065 &sensor_dev_attr_sf2_level##offset##_fan##index.dev_attr); \ 1066 } while (0) 1067 1068 1069 /* This function is called when: 1070 * w83792d_driver is inserted (when this module is loaded), for each 1071 available adapter 1072 * when a new adapter is inserted (and w83792d_driver is still present) */ 1073 static int 1074 w83792d_attach_adapter(struct i2c_adapter *adapter) 1075 { 1076 if (!(adapter->class & I2C_CLASS_HWMON)) 1077 return 0; 1078 return i2c_probe(adapter, &addr_data, w83792d_detect); 1079 } 1080 1081 1082 static int 1083 w83792d_create_subclient(struct i2c_adapter *adapter, 1084 struct i2c_client *new_client, int addr, 1085 struct i2c_client **sub_cli) 1086 { 1087 int err; 1088 struct i2c_client *sub_client; 1089 1090 (*sub_cli) = sub_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL); 1091 if (!(sub_client)) { 1092 return -ENOMEM; 1093 } 1094 sub_client->addr = 0x48 + addr; 1095 i2c_set_clientdata(sub_client, NULL); 1096 sub_client->adapter = adapter; 1097 sub_client->driver = &w83792d_driver; 1098 sub_client->flags = 0; 1099 strlcpy(sub_client->name, "w83792d subclient", I2C_NAME_SIZE); 1100 if ((err = i2c_attach_client(sub_client))) { 1101 dev_err(&new_client->dev, "subclient registration " 1102 "at address 0x%x failed\n", sub_client->addr); 1103 kfree(sub_client); 1104 return err; 1105 } 1106 return 0; 1107 } 1108 1109 1110 static int 1111 w83792d_detect_subclients(struct i2c_adapter *adapter, int address, int kind, 1112 struct i2c_client *new_client) 1113 { 1114 int i, id, err; 1115 u8 val; 1116 struct w83792d_data *data = i2c_get_clientdata(new_client); 1117 1118 id = i2c_adapter_id(adapter); 1119 if (force_subclients[0] == id && force_subclients[1] == address) { 1120 for (i = 2; i <= 3; i++) { 1121 if (force_subclients[i] < 0x48 || 1122 force_subclients[i] > 0x4f) { 1123 dev_err(&new_client->dev, "invalid subclient " 1124 "address %d; must be 0x48-0x4f\n", 1125 force_subclients[i]); 1126 err = -ENODEV; 1127 goto ERROR_SC_0; 1128 } 1129 } 1130 w83792d_write_value(new_client, W83792D_REG_I2C_SUBADDR, 1131 (force_subclients[2] & 0x07) | 1132 ((force_subclients[3] & 0x07) << 4)); 1133 } 1134 1135 val = w83792d_read_value(new_client, W83792D_REG_I2C_SUBADDR); 1136 if (!(val & 0x08)) { 1137 err = w83792d_create_subclient(adapter, new_client, val & 0x7, 1138 &data->lm75[0]); 1139 if (err < 0) 1140 goto ERROR_SC_0; 1141 } 1142 if (!(val & 0x80)) { 1143 if ((data->lm75[0] != NULL) && 1144 ((val & 0x7) == ((val >> 4) & 0x7))) { 1145 dev_err(&new_client->dev, "duplicate addresses 0x%x, " 1146 "use force_subclient\n", data->lm75[0]->addr); 1147 err = -ENODEV; 1148 goto ERROR_SC_1; 1149 } 1150 err = w83792d_create_subclient(adapter, new_client, 1151 (val >> 4) & 0x7, &data->lm75[1]); 1152 if (err < 0) 1153 goto ERROR_SC_1; 1154 } 1155 1156 return 0; 1157 1158 /* Undo inits in case of errors */ 1159 1160 ERROR_SC_1: 1161 if (data->lm75[0] != NULL) { 1162 i2c_detach_client(data->lm75[0]); 1163 kfree(data->lm75[0]); 1164 } 1165 ERROR_SC_0: 1166 return err; 1167 } 1168 1169 1170 static int 1171 w83792d_detect(struct i2c_adapter *adapter, int address, int kind) 1172 { 1173 int i = 0, val1 = 0, val2; 1174 struct i2c_client *new_client; 1175 struct w83792d_data *data; 1176 int err = 0; 1177 const char *client_name = ""; 1178 1179 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) { 1180 goto ERROR0; 1181 } 1182 1183 /* OK. For now, we presume we have a valid client. We now create the 1184 client structure, even though we cannot fill it completely yet. 1185 But it allows us to access w83792d_{read,write}_value. */ 1186 1187 if (!(data = kzalloc(sizeof(struct w83792d_data), GFP_KERNEL))) { 1188 err = -ENOMEM; 1189 goto ERROR0; 1190 } 1191 1192 new_client = &data->client; 1193 i2c_set_clientdata(new_client, data); 1194 new_client->addr = address; 1195 init_MUTEX(&data->lock); 1196 new_client->adapter = adapter; 1197 new_client->driver = &w83792d_driver; 1198 new_client->flags = 0; 1199 1200 /* Now, we do the remaining detection. */ 1201 1202 /* The w83792d may be stuck in some other bank than bank 0. This may 1203 make reading other information impossible. Specify a force=... or 1204 force_*=... parameter, and the Winbond will be reset to the right 1205 bank. */ 1206 if (kind < 0) { 1207 if (w83792d_read_value(new_client, W83792D_REG_CONFIG) & 0x80) { 1208 dev_warn(&new_client->dev, "Detection failed at step " 1209 "3\n"); 1210 goto ERROR1; 1211 } 1212 val1 = w83792d_read_value(new_client, W83792D_REG_BANK); 1213 val2 = w83792d_read_value(new_client, W83792D_REG_CHIPMAN); 1214 /* Check for Winbond ID if in bank 0 */ 1215 if (!(val1 & 0x07)) { /* is Bank0 */ 1216 if (((!(val1 & 0x80)) && (val2 != 0xa3)) || 1217 ((val1 & 0x80) && (val2 != 0x5c))) { 1218 goto ERROR1; 1219 } 1220 } 1221 /* If Winbond chip, address of chip and W83792D_REG_I2C_ADDR 1222 should match */ 1223 if (w83792d_read_value(new_client, 1224 W83792D_REG_I2C_ADDR) != address) { 1225 dev_warn(&new_client->dev, "Detection failed " 1226 "at step 5\n"); 1227 goto ERROR1; 1228 } 1229 } 1230 1231 /* We have either had a force parameter, or we have already detected the 1232 Winbond. Put it now into bank 0 and Vendor ID High Byte */ 1233 w83792d_write_value(new_client, 1234 W83792D_REG_BANK, 1235 (w83792d_read_value(new_client, 1236 W83792D_REG_BANK) & 0x78) | 0x80); 1237 1238 /* Determine the chip type. */ 1239 if (kind <= 0) { 1240 /* get vendor ID */ 1241 val2 = w83792d_read_value(new_client, W83792D_REG_CHIPMAN); 1242 if (val2 != 0x5c) { /* the vendor is NOT Winbond */ 1243 goto ERROR1; 1244 } 1245 val1 = w83792d_read_value(new_client, W83792D_REG_WCHIPID); 1246 if (val1 == 0x7a && address >= 0x2c) { 1247 kind = w83792d; 1248 } else { 1249 if (kind == 0) 1250 dev_warn(&new_client->dev, 1251 "w83792d: Ignoring 'force' parameter for" 1252 " unknown chip at adapter %d, address" 1253 " 0x%02x\n", i2c_adapter_id(adapter), 1254 address); 1255 goto ERROR1; 1256 } 1257 } 1258 1259 if (kind == w83792d) { 1260 client_name = "w83792d"; 1261 } else { 1262 dev_err(&new_client->dev, "w83792d: Internal error: unknown" 1263 " kind (%d)?!?", kind); 1264 goto ERROR1; 1265 } 1266 1267 /* Fill in the remaining client fields and put into the global list */ 1268 strlcpy(new_client->name, client_name, I2C_NAME_SIZE); 1269 data->type = kind; 1270 1271 data->valid = 0; 1272 init_MUTEX(&data->update_lock); 1273 1274 /* Tell the I2C layer a new client has arrived */ 1275 if ((err = i2c_attach_client(new_client))) 1276 goto ERROR1; 1277 1278 if ((err = w83792d_detect_subclients(adapter, address, 1279 kind, new_client))) 1280 goto ERROR2; 1281 1282 /* Initialize the chip */ 1283 w83792d_init_client(new_client); 1284 1285 /* A few vars need to be filled upon startup */ 1286 for (i = 0; i < 7; i++) { 1287 data->fan_min[i] = w83792d_read_value(new_client, 1288 W83792D_REG_FAN_MIN[i]); 1289 } 1290 1291 /* Register sysfs hooks */ 1292 data->class_dev = hwmon_device_register(&new_client->dev); 1293 if (IS_ERR(data->class_dev)) { 1294 err = PTR_ERR(data->class_dev); 1295 goto ERROR3; 1296 } 1297 device_create_file_in(new_client, 0); 1298 device_create_file_in(new_client, 1); 1299 device_create_file_in(new_client, 2); 1300 device_create_file_in(new_client, 3); 1301 device_create_file_in(new_client, 4); 1302 device_create_file_in(new_client, 5); 1303 device_create_file_in(new_client, 6); 1304 device_create_file_in(new_client, 7); 1305 device_create_file_in(new_client, 8); 1306 1307 device_create_file_fan(new_client, 1); 1308 device_create_file_fan(new_client, 2); 1309 device_create_file_fan(new_client, 3); 1310 1311 /* Read GPIO enable register to check if pins for fan 4,5 are used as 1312 GPIO */ 1313 val1 = w83792d_read_value(new_client, W83792D_REG_GPIO_EN); 1314 if (!(val1 & 0x40)) 1315 device_create_file_fan(new_client, 4); 1316 if (!(val1 & 0x20)) 1317 device_create_file_fan(new_client, 5); 1318 1319 val1 = w83792d_read_value(new_client, W83792D_REG_PIN); 1320 if (val1 & 0x40) 1321 device_create_file_fan(new_client, 6); 1322 if (val1 & 0x04) 1323 device_create_file_fan(new_client, 7); 1324 1325 device_create_file_temp1(new_client); /* Temp1 */ 1326 device_create_file_temp_add(new_client, 2); /* Temp2 */ 1327 device_create_file_temp_add(new_client, 3); /* Temp3 */ 1328 1329 device_create_file_alarms(new_client); 1330 1331 device_create_file_pwm(new_client, 1); 1332 device_create_file_pwm(new_client, 2); 1333 device_create_file_pwm(new_client, 3); 1334 1335 device_create_file_pwmenable(new_client, 1); 1336 device_create_file_pwmenable(new_client, 2); 1337 device_create_file_pwmenable(new_client, 3); 1338 1339 device_create_file_pwm_mode(new_client, 1); 1340 device_create_file_pwm_mode(new_client, 2); 1341 device_create_file_pwm_mode(new_client, 3); 1342 1343 device_create_file_chassis(new_client); 1344 device_create_file_chassis_clear(new_client); 1345 1346 device_create_file_thermal_cruise(new_client, 1); 1347 device_create_file_thermal_cruise(new_client, 2); 1348 device_create_file_thermal_cruise(new_client, 3); 1349 1350 device_create_file_tolerance(new_client, 1); 1351 device_create_file_tolerance(new_client, 2); 1352 device_create_file_tolerance(new_client, 3); 1353 1354 device_create_file_sf2_point(new_client, 1, 1); /* Fan1 */ 1355 device_create_file_sf2_point(new_client, 2, 1); /* Fan1 */ 1356 device_create_file_sf2_point(new_client, 3, 1); /* Fan1 */ 1357 device_create_file_sf2_point(new_client, 4, 1); /* Fan1 */ 1358 device_create_file_sf2_point(new_client, 1, 2); /* Fan2 */ 1359 device_create_file_sf2_point(new_client, 2, 2); /* Fan2 */ 1360 device_create_file_sf2_point(new_client, 3, 2); /* Fan2 */ 1361 device_create_file_sf2_point(new_client, 4, 2); /* Fan2 */ 1362 device_create_file_sf2_point(new_client, 1, 3); /* Fan3 */ 1363 device_create_file_sf2_point(new_client, 2, 3); /* Fan3 */ 1364 device_create_file_sf2_point(new_client, 3, 3); /* Fan3 */ 1365 device_create_file_sf2_point(new_client, 4, 3); /* Fan3 */ 1366 1367 device_create_file_sf2_level(new_client, 1, 1); /* Fan1 */ 1368 device_create_file_sf2_level(new_client, 2, 1); /* Fan1 */ 1369 device_create_file_sf2_level(new_client, 3, 1); /* Fan1 */ 1370 device_create_file_sf2_level(new_client, 1, 2); /* Fan2 */ 1371 device_create_file_sf2_level(new_client, 2, 2); /* Fan2 */ 1372 device_create_file_sf2_level(new_client, 3, 2); /* Fan2 */ 1373 device_create_file_sf2_level(new_client, 1, 3); /* Fan3 */ 1374 device_create_file_sf2_level(new_client, 2, 3); /* Fan3 */ 1375 device_create_file_sf2_level(new_client, 3, 3); /* Fan3 */ 1376 1377 return 0; 1378 1379 ERROR3: 1380 if (data->lm75[0] != NULL) { 1381 i2c_detach_client(data->lm75[0]); 1382 kfree(data->lm75[0]); 1383 } 1384 if (data->lm75[1] != NULL) { 1385 i2c_detach_client(data->lm75[1]); 1386 kfree(data->lm75[1]); 1387 } 1388 ERROR2: 1389 i2c_detach_client(new_client); 1390 ERROR1: 1391 kfree(data); 1392 ERROR0: 1393 return err; 1394 } 1395 1396 static int 1397 w83792d_detach_client(struct i2c_client *client) 1398 { 1399 struct w83792d_data *data = i2c_get_clientdata(client); 1400 int err; 1401 1402 /* main client */ 1403 if (data) 1404 hwmon_device_unregister(data->class_dev); 1405 1406 if ((err = i2c_detach_client(client))) 1407 return err; 1408 1409 /* main client */ 1410 if (data) 1411 kfree(data); 1412 /* subclient */ 1413 else 1414 kfree(client); 1415 1416 return 0; 1417 } 1418 1419 /* The SMBus locks itself, usually, but nothing may access the Winbond between 1420 bank switches. ISA access must always be locked explicitly! 1421 We ignore the W83792D BUSY flag at this moment - it could lead to deadlocks, 1422 would slow down the W83792D access and should not be necessary. 1423 There are some ugly typecasts here, but the good news is - they should 1424 nowhere else be necessary! */ 1425 static int 1426 w83792d_read_value(struct i2c_client *client, u8 reg) 1427 { 1428 int res=0; 1429 res = i2c_smbus_read_byte_data(client, reg); 1430 1431 return res; 1432 } 1433 1434 static int 1435 w83792d_write_value(struct i2c_client *client, u8 reg, u8 value) 1436 { 1437 i2c_smbus_write_byte_data(client, reg, value); 1438 return 0; 1439 } 1440 1441 static void 1442 w83792d_init_client(struct i2c_client *client) 1443 { 1444 u8 temp2_cfg, temp3_cfg, vid_in_b; 1445 1446 if (init) { 1447 w83792d_write_value(client, W83792D_REG_CONFIG, 0x80); 1448 } 1449 /* Clear the bit6 of W83792D_REG_VID_IN_B(set it into 0): 1450 W83792D_REG_VID_IN_B bit6 = 0: the high/low limit of 1451 vin0/vin1 can be modified by user; 1452 W83792D_REG_VID_IN_B bit6 = 1: the high/low limit of 1453 vin0/vin1 auto-updated, can NOT be modified by user. */ 1454 vid_in_b = w83792d_read_value(client, W83792D_REG_VID_IN_B); 1455 w83792d_write_value(client, W83792D_REG_VID_IN_B, 1456 vid_in_b & 0xbf); 1457 1458 temp2_cfg = w83792d_read_value(client, W83792D_REG_TEMP2_CONFIG); 1459 temp3_cfg = w83792d_read_value(client, W83792D_REG_TEMP3_CONFIG); 1460 w83792d_write_value(client, W83792D_REG_TEMP2_CONFIG, 1461 temp2_cfg & 0xe6); 1462 w83792d_write_value(client, W83792D_REG_TEMP3_CONFIG, 1463 temp3_cfg & 0xe6); 1464 1465 /* Start monitoring */ 1466 w83792d_write_value(client, W83792D_REG_CONFIG, 1467 (w83792d_read_value(client, 1468 W83792D_REG_CONFIG) & 0xf7) 1469 | 0x01); 1470 } 1471 1472 static struct w83792d_data *w83792d_update_device(struct device *dev) 1473 { 1474 struct i2c_client *client = to_i2c_client(dev); 1475 struct w83792d_data *data = i2c_get_clientdata(client); 1476 int i, j; 1477 u8 reg_array_tmp[4], pwm_array_tmp[7], reg_tmp; 1478 1479 down(&data->update_lock); 1480 1481 if (time_after 1482 (jiffies - data->last_updated, (unsigned long) (HZ * 3)) 1483 || time_before(jiffies, data->last_updated) || !data->valid) { 1484 dev_dbg(dev, "Starting device update\n"); 1485 1486 /* Update the voltages measured value and limits */ 1487 for (i = 0; i < 9; i++) { 1488 data->in[i] = w83792d_read_value(client, 1489 W83792D_REG_IN[i]); 1490 data->in_max[i] = w83792d_read_value(client, 1491 W83792D_REG_IN_MAX[i]); 1492 data->in_min[i] = w83792d_read_value(client, 1493 W83792D_REG_IN_MIN[i]); 1494 } 1495 data->low_bits[0] = w83792d_read_value(client, 1496 W83792D_REG_LOW_BITS1); 1497 data->low_bits[1] = w83792d_read_value(client, 1498 W83792D_REG_LOW_BITS2); 1499 for (i = 0; i < 7; i++) { 1500 /* Update the Fan measured value and limits */ 1501 data->fan[i] = w83792d_read_value(client, 1502 W83792D_REG_FAN[i]); 1503 data->fan_min[i] = w83792d_read_value(client, 1504 W83792D_REG_FAN_MIN[i]); 1505 /* Update the PWM/DC Value and PWM/DC flag */ 1506 pwm_array_tmp[i] = w83792d_read_value(client, 1507 W83792D_REG_PWM[i]); 1508 data->pwm[i] = pwm_array_tmp[i] & 0x0f; 1509 data->pwm_mode[i] = (pwm_array_tmp[i] >> 7) & 0x01; 1510 } 1511 1512 reg_tmp = w83792d_read_value(client, W83792D_REG_FAN_CFG); 1513 data->pwmenable[0] = reg_tmp & 0x03; 1514 data->pwmenable[1] = (reg_tmp>>2) & 0x03; 1515 data->pwmenable[2] = (reg_tmp>>4) & 0x03; 1516 1517 for (i = 0; i < 3; i++) { 1518 data->temp1[i] = w83792d_read_value(client, 1519 W83792D_REG_TEMP1[i]); 1520 } 1521 for (i = 0; i < 2; i++) { 1522 for (j = 0; j < 6; j++) { 1523 data->temp_add[i][j] = w83792d_read_value( 1524 client,W83792D_REG_TEMP_ADD[i][j]); 1525 } 1526 } 1527 1528 /* Update the Fan Divisor */ 1529 for (i = 0; i < 4; i++) { 1530 reg_array_tmp[i] = w83792d_read_value(client, 1531 W83792D_REG_FAN_DIV[i]); 1532 } 1533 data->fan_div[0] = reg_array_tmp[0] & 0x07; 1534 data->fan_div[1] = (reg_array_tmp[0] >> 4) & 0x07; 1535 data->fan_div[2] = reg_array_tmp[1] & 0x07; 1536 data->fan_div[3] = (reg_array_tmp[1] >> 4) & 0x07; 1537 data->fan_div[4] = reg_array_tmp[2] & 0x07; 1538 data->fan_div[5] = (reg_array_tmp[2] >> 4) & 0x07; 1539 data->fan_div[6] = reg_array_tmp[3] & 0x07; 1540 1541 /* Update the realtime status */ 1542 data->alarms = w83792d_read_value(client, W83792D_REG_ALARM1) + 1543 (w83792d_read_value(client, W83792D_REG_ALARM2) << 8) + 1544 (w83792d_read_value(client, W83792D_REG_ALARM3) << 16); 1545 1546 /* Update CaseOpen status and it's CLR_CHS. */ 1547 data->chassis = (w83792d_read_value(client, 1548 W83792D_REG_CHASSIS) >> 5) & 0x01; 1549 data->chassis_clear = (w83792d_read_value(client, 1550 W83792D_REG_CHASSIS_CLR) >> 7) & 0x01; 1551 1552 /* Update Thermal Cruise/Smart Fan I target value */ 1553 for (i = 0; i < 3; i++) { 1554 data->thermal_cruise[i] = 1555 w83792d_read_value(client, 1556 W83792D_REG_THERMAL[i]) & 0x7f; 1557 } 1558 1559 /* Update Smart Fan I/II tolerance */ 1560 reg_tmp = w83792d_read_value(client, W83792D_REG_TOLERANCE[0]); 1561 data->tolerance[0] = reg_tmp & 0x0f; 1562 data->tolerance[1] = (reg_tmp >> 4) & 0x0f; 1563 data->tolerance[2] = w83792d_read_value(client, 1564 W83792D_REG_TOLERANCE[2]) & 0x0f; 1565 1566 /* Update Smart Fan II temperature points */ 1567 for (i = 0; i < 3; i++) { 1568 for (j = 0; j < 4; j++) { 1569 data->sf2_points[i][j] = w83792d_read_value( 1570 client,W83792D_REG_POINTS[i][j]) & 0x7f; 1571 } 1572 } 1573 1574 /* Update Smart Fan II duty cycle levels */ 1575 for (i = 0; i < 3; i++) { 1576 reg_tmp = w83792d_read_value(client, 1577 W83792D_REG_LEVELS[i][0]); 1578 data->sf2_levels[i][0] = reg_tmp & 0x0f; 1579 data->sf2_levels[i][1] = (reg_tmp >> 4) & 0x0f; 1580 reg_tmp = w83792d_read_value(client, 1581 W83792D_REG_LEVELS[i][2]); 1582 data->sf2_levels[i][2] = (reg_tmp >> 4) & 0x0f; 1583 data->sf2_levels[i][3] = reg_tmp & 0x0f; 1584 } 1585 1586 data->last_updated = jiffies; 1587 data->valid = 1; 1588 } 1589 1590 up(&data->update_lock); 1591 1592 #ifdef DEBUG 1593 w83792d_print_debug(data, dev); 1594 #endif 1595 1596 return data; 1597 } 1598 1599 #ifdef DEBUG 1600 static void w83792d_print_debug(struct w83792d_data *data, struct device *dev) 1601 { 1602 int i=0, j=0; 1603 dev_dbg(dev, "==========The following is the debug message...========\n"); 1604 dev_dbg(dev, "9 set of Voltages: =====>\n"); 1605 for (i=0; i<9; i++) { 1606 dev_dbg(dev, "vin[%d] is: 0x%x\n", i, data->in[i]); 1607 dev_dbg(dev, "vin[%d] max is: 0x%x\n", i, data->in_max[i]); 1608 dev_dbg(dev, "vin[%d] min is: 0x%x\n", i, data->in_min[i]); 1609 } 1610 dev_dbg(dev, "Low Bit1 is: 0x%x\n", data->low_bits[0]); 1611 dev_dbg(dev, "Low Bit2 is: 0x%x\n", data->low_bits[1]); 1612 dev_dbg(dev, "7 set of Fan Counts and Duty Cycles: =====>\n"); 1613 for (i=0; i<7; i++) { 1614 dev_dbg(dev, "fan[%d] is: 0x%x\n", i, data->fan[i]); 1615 dev_dbg(dev, "fan[%d] min is: 0x%x\n", i, data->fan_min[i]); 1616 dev_dbg(dev, "pwm[%d] is: 0x%x\n", i, data->pwm[i]); 1617 dev_dbg(dev, "pwm_mode[%d] is: 0x%x\n", i, data->pwm_mode[i]); 1618 } 1619 dev_dbg(dev, "3 set of Temperatures: =====>\n"); 1620 for (i=0; i<3; i++) { 1621 dev_dbg(dev, "temp1[%d] is: 0x%x\n", i, data->temp1[i]); 1622 } 1623 1624 for (i=0; i<2; i++) { 1625 for (j=0; j<6; j++) { 1626 dev_dbg(dev, "temp_add[%d][%d] is: 0x%x\n", i, j, 1627 data->temp_add[i][j]); 1628 } 1629 } 1630 1631 for (i=0; i<7; i++) { 1632 dev_dbg(dev, "fan_div[%d] is: 0x%x\n", i, data->fan_div[i]); 1633 } 1634 dev_dbg(dev, "==========End of the debug message...==================\n"); 1635 dev_dbg(dev, "\n"); 1636 } 1637 #endif 1638 1639 static int __init 1640 sensors_w83792d_init(void) 1641 { 1642 return i2c_add_driver(&w83792d_driver); 1643 } 1644 1645 static void __exit 1646 sensors_w83792d_exit(void) 1647 { 1648 i2c_del_driver(&w83792d_driver); 1649 } 1650 1651 MODULE_AUTHOR("Chunhao Huang @ Winbond <DZShen@Winbond.com.tw>"); 1652 MODULE_DESCRIPTION("W83792AD/D driver for linux-2.6"); 1653 MODULE_LICENSE("GPL"); 1654 1655 module_init(sensors_w83792d_init); 1656 module_exit(sensors_w83792d_exit); 1657 1658