1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * asc7621.c - Part of lm_sensors, Linux kernel modules for hardware monitoring 4 * Copyright (c) 2007, 2010 George Joseph <george.joseph@fairview5.com> 5 */ 6 7 #include <linux/module.h> 8 #include <linux/init.h> 9 #include <linux/slab.h> 10 #include <linux/jiffies.h> 11 #include <linux/i2c.h> 12 #include <linux/hwmon.h> 13 #include <linux/hwmon-sysfs.h> 14 #include <linux/err.h> 15 #include <linux/mutex.h> 16 17 /* Addresses to scan */ 18 static const unsigned short normal_i2c[] = { 19 0x2c, 0x2d, 0x2e, I2C_CLIENT_END 20 }; 21 22 enum asc7621_type { 23 asc7621, 24 asc7621a 25 }; 26 27 #define INTERVAL_HIGH (HZ + HZ / 2) 28 #define INTERVAL_LOW (1 * 60 * HZ) 29 #define PRI_NONE 0 30 #define PRI_LOW 1 31 #define PRI_HIGH 2 32 #define FIRST_CHIP asc7621 33 #define LAST_CHIP asc7621a 34 35 struct asc7621_chip { 36 char *name; 37 enum asc7621_type chip_type; 38 u8 company_reg; 39 u8 company_id; 40 u8 verstep_reg; 41 u8 verstep_id; 42 const unsigned short *addresses; 43 }; 44 45 static struct asc7621_chip asc7621_chips[] = { 46 { 47 .name = "asc7621", 48 .chip_type = asc7621, 49 .company_reg = 0x3e, 50 .company_id = 0x61, 51 .verstep_reg = 0x3f, 52 .verstep_id = 0x6c, 53 .addresses = normal_i2c, 54 }, 55 { 56 .name = "asc7621a", 57 .chip_type = asc7621a, 58 .company_reg = 0x3e, 59 .company_id = 0x61, 60 .verstep_reg = 0x3f, 61 .verstep_id = 0x6d, 62 .addresses = normal_i2c, 63 }, 64 }; 65 66 /* 67 * Defines the highest register to be used, not the count. 68 * The actual count will probably be smaller because of gaps 69 * in the implementation (unused register locations). 70 * This define will safely set the array size of both the parameter 71 * and data arrays. 72 * This comes from the data sheet register description table. 73 */ 74 #define LAST_REGISTER 0xff 75 76 struct asc7621_data { 77 struct i2c_client client; 78 struct device *class_dev; 79 struct mutex update_lock; 80 int valid; /* !=0 if following fields are valid */ 81 unsigned long last_high_reading; /* In jiffies */ 82 unsigned long last_low_reading; /* In jiffies */ 83 /* 84 * Registers we care about occupy the corresponding index 85 * in the array. Registers we don't care about are left 86 * at 0. 87 */ 88 u8 reg[LAST_REGISTER + 1]; 89 }; 90 91 /* 92 * Macro to get the parent asc7621_param structure 93 * from a sensor_device_attribute passed into the 94 * show/store functions. 95 */ 96 #define to_asc7621_param(_sda) \ 97 container_of(_sda, struct asc7621_param, sda) 98 99 /* 100 * Each parameter to be retrieved needs an asc7621_param structure 101 * allocated. It contains the sensor_device_attribute structure 102 * and the control info needed to retrieve the value from the register map. 103 */ 104 struct asc7621_param { 105 struct sensor_device_attribute sda; 106 u8 priority; 107 u8 msb[3]; 108 u8 lsb[3]; 109 u8 mask[3]; 110 u8 shift[3]; 111 }; 112 113 /* 114 * This is the map that ultimately indicates whether we'll be 115 * retrieving a register value or not, and at what frequency. 116 */ 117 static u8 asc7621_register_priorities[255]; 118 119 static struct asc7621_data *asc7621_update_device(struct device *dev); 120 121 static inline u8 read_byte(struct i2c_client *client, u8 reg) 122 { 123 int res = i2c_smbus_read_byte_data(client, reg); 124 if (res < 0) { 125 dev_err(&client->dev, 126 "Unable to read from register 0x%02x.\n", reg); 127 return 0; 128 } 129 return res & 0xff; 130 } 131 132 static inline int write_byte(struct i2c_client *client, u8 reg, u8 data) 133 { 134 int res = i2c_smbus_write_byte_data(client, reg, data); 135 if (res < 0) { 136 dev_err(&client->dev, 137 "Unable to write value 0x%02x to register 0x%02x.\n", 138 data, reg); 139 } 140 return res; 141 } 142 143 /* 144 * Data Handlers 145 * Each function handles the formatting, storage 146 * and retrieval of like parameters. 147 */ 148 149 #define SETUP_SHOW_DATA_PARAM(d, a) \ 150 struct sensor_device_attribute *sda = to_sensor_dev_attr(a); \ 151 struct asc7621_data *data = asc7621_update_device(d); \ 152 struct asc7621_param *param = to_asc7621_param(sda) 153 154 #define SETUP_STORE_DATA_PARAM(d, a) \ 155 struct sensor_device_attribute *sda = to_sensor_dev_attr(a); \ 156 struct i2c_client *client = to_i2c_client(d); \ 157 struct asc7621_data *data = i2c_get_clientdata(client); \ 158 struct asc7621_param *param = to_asc7621_param(sda) 159 160 /* 161 * u8 is just what it sounds like...an unsigned byte with no 162 * special formatting. 163 */ 164 static ssize_t show_u8(struct device *dev, struct device_attribute *attr, 165 char *buf) 166 { 167 SETUP_SHOW_DATA_PARAM(dev, attr); 168 169 return sprintf(buf, "%u\n", data->reg[param->msb[0]]); 170 } 171 172 static ssize_t store_u8(struct device *dev, struct device_attribute *attr, 173 const char *buf, size_t count) 174 { 175 SETUP_STORE_DATA_PARAM(dev, attr); 176 long reqval; 177 178 if (kstrtol(buf, 10, &reqval)) 179 return -EINVAL; 180 181 reqval = clamp_val(reqval, 0, 255); 182 183 mutex_lock(&data->update_lock); 184 data->reg[param->msb[0]] = reqval; 185 write_byte(client, param->msb[0], reqval); 186 mutex_unlock(&data->update_lock); 187 return count; 188 } 189 190 /* 191 * Many of the config values occupy only a few bits of a register. 192 */ 193 static ssize_t show_bitmask(struct device *dev, 194 struct device_attribute *attr, char *buf) 195 { 196 SETUP_SHOW_DATA_PARAM(dev, attr); 197 198 return sprintf(buf, "%u\n", 199 (data->reg[param->msb[0]] >> param-> 200 shift[0]) & param->mask[0]); 201 } 202 203 static ssize_t store_bitmask(struct device *dev, 204 struct device_attribute *attr, 205 const char *buf, size_t count) 206 { 207 SETUP_STORE_DATA_PARAM(dev, attr); 208 long reqval; 209 u8 currval; 210 211 if (kstrtol(buf, 10, &reqval)) 212 return -EINVAL; 213 214 reqval = clamp_val(reqval, 0, param->mask[0]); 215 216 reqval = (reqval & param->mask[0]) << param->shift[0]; 217 218 mutex_lock(&data->update_lock); 219 currval = read_byte(client, param->msb[0]); 220 reqval |= (currval & ~(param->mask[0] << param->shift[0])); 221 data->reg[param->msb[0]] = reqval; 222 write_byte(client, param->msb[0], reqval); 223 mutex_unlock(&data->update_lock); 224 return count; 225 } 226 227 /* 228 * 16 bit fan rpm values 229 * reported by the device as the number of 11.111us periods (90khz) 230 * between full fan rotations. Therefore... 231 * RPM = (90000 * 60) / register value 232 */ 233 static ssize_t show_fan16(struct device *dev, 234 struct device_attribute *attr, char *buf) 235 { 236 SETUP_SHOW_DATA_PARAM(dev, attr); 237 u16 regval; 238 239 mutex_lock(&data->update_lock); 240 regval = (data->reg[param->msb[0]] << 8) | data->reg[param->lsb[0]]; 241 mutex_unlock(&data->update_lock); 242 243 return sprintf(buf, "%u\n", 244 (regval == 0 ? -1 : (regval) == 245 0xffff ? 0 : 5400000 / regval)); 246 } 247 248 static ssize_t store_fan16(struct device *dev, 249 struct device_attribute *attr, const char *buf, 250 size_t count) 251 { 252 SETUP_STORE_DATA_PARAM(dev, attr); 253 long reqval; 254 255 if (kstrtol(buf, 10, &reqval)) 256 return -EINVAL; 257 258 /* 259 * If a minimum RPM of zero is requested, then we set the register to 260 * 0xffff. This value allows the fan to be stopped completely without 261 * generating an alarm. 262 */ 263 reqval = 264 (reqval <= 0 ? 0xffff : clamp_val(5400000 / reqval, 0, 0xfffe)); 265 266 mutex_lock(&data->update_lock); 267 data->reg[param->msb[0]] = (reqval >> 8) & 0xff; 268 data->reg[param->lsb[0]] = reqval & 0xff; 269 write_byte(client, param->msb[0], data->reg[param->msb[0]]); 270 write_byte(client, param->lsb[0], data->reg[param->lsb[0]]); 271 mutex_unlock(&data->update_lock); 272 273 return count; 274 } 275 276 /* 277 * Voltages are scaled in the device so that the nominal voltage 278 * is 3/4ths of the 0-255 range (i.e. 192). 279 * If all voltages are 'normal' then all voltage registers will 280 * read 0xC0. 281 * 282 * The data sheet provides us with the 3/4 scale value for each voltage 283 * which is stored in in_scaling. The sda->index parameter value provides 284 * the index into in_scaling. 285 * 286 * NOTE: The chip expects the first 2 inputs be 2.5 and 2.25 volts 287 * respectively. That doesn't mean that's what the motherboard provides. :) 288 */ 289 290 static const int asc7621_in_scaling[] = { 291 2500, 2250, 3300, 5000, 12000 292 }; 293 294 static ssize_t show_in10(struct device *dev, struct device_attribute *attr, 295 char *buf) 296 { 297 SETUP_SHOW_DATA_PARAM(dev, attr); 298 u16 regval; 299 u8 nr = sda->index; 300 301 mutex_lock(&data->update_lock); 302 regval = (data->reg[param->msb[0]] << 8) | (data->reg[param->lsb[0]]); 303 mutex_unlock(&data->update_lock); 304 305 /* The LSB value is a 2-bit scaling of the MSB's LSbit value. */ 306 regval = (regval >> 6) * asc7621_in_scaling[nr] / (0xc0 << 2); 307 308 return sprintf(buf, "%u\n", regval); 309 } 310 311 /* 8 bit voltage values (the mins and maxs) */ 312 static ssize_t show_in8(struct device *dev, struct device_attribute *attr, 313 char *buf) 314 { 315 SETUP_SHOW_DATA_PARAM(dev, attr); 316 u8 nr = sda->index; 317 318 return sprintf(buf, "%u\n", 319 ((data->reg[param->msb[0]] * 320 asc7621_in_scaling[nr]) / 0xc0)); 321 } 322 323 static ssize_t store_in8(struct device *dev, struct device_attribute *attr, 324 const char *buf, size_t count) 325 { 326 SETUP_STORE_DATA_PARAM(dev, attr); 327 long reqval; 328 u8 nr = sda->index; 329 330 if (kstrtol(buf, 10, &reqval)) 331 return -EINVAL; 332 333 reqval = clamp_val(reqval, 0, 0xffff); 334 335 reqval = reqval * 0xc0 / asc7621_in_scaling[nr]; 336 337 reqval = clamp_val(reqval, 0, 0xff); 338 339 mutex_lock(&data->update_lock); 340 data->reg[param->msb[0]] = reqval; 341 write_byte(client, param->msb[0], reqval); 342 mutex_unlock(&data->update_lock); 343 344 return count; 345 } 346 347 static ssize_t show_temp8(struct device *dev, 348 struct device_attribute *attr, char *buf) 349 { 350 SETUP_SHOW_DATA_PARAM(dev, attr); 351 352 return sprintf(buf, "%d\n", ((s8) data->reg[param->msb[0]]) * 1000); 353 } 354 355 static ssize_t store_temp8(struct device *dev, 356 struct device_attribute *attr, const char *buf, 357 size_t count) 358 { 359 SETUP_STORE_DATA_PARAM(dev, attr); 360 long reqval; 361 s8 temp; 362 363 if (kstrtol(buf, 10, &reqval)) 364 return -EINVAL; 365 366 reqval = clamp_val(reqval, -127000, 127000); 367 368 temp = reqval / 1000; 369 370 mutex_lock(&data->update_lock); 371 data->reg[param->msb[0]] = temp; 372 write_byte(client, param->msb[0], temp); 373 mutex_unlock(&data->update_lock); 374 return count; 375 } 376 377 /* 378 * Temperatures that occupy 2 bytes always have the whole 379 * number of degrees in the MSB with some part of the LSB 380 * indicating fractional degrees. 381 */ 382 383 /* mmmmmmmm.llxxxxxx */ 384 static ssize_t show_temp10(struct device *dev, 385 struct device_attribute *attr, char *buf) 386 { 387 SETUP_SHOW_DATA_PARAM(dev, attr); 388 u8 msb, lsb; 389 int temp; 390 391 mutex_lock(&data->update_lock); 392 msb = data->reg[param->msb[0]]; 393 lsb = (data->reg[param->lsb[0]] >> 6) & 0x03; 394 temp = (((s8) msb) * 1000) + (lsb * 250); 395 mutex_unlock(&data->update_lock); 396 397 return sprintf(buf, "%d\n", temp); 398 } 399 400 /* mmmmmm.ll */ 401 static ssize_t show_temp62(struct device *dev, 402 struct device_attribute *attr, char *buf) 403 { 404 SETUP_SHOW_DATA_PARAM(dev, attr); 405 u8 regval = data->reg[param->msb[0]]; 406 int temp = ((s8) (regval & 0xfc) * 1000) + ((regval & 0x03) * 250); 407 408 return sprintf(buf, "%d\n", temp); 409 } 410 411 static ssize_t store_temp62(struct device *dev, 412 struct device_attribute *attr, const char *buf, 413 size_t count) 414 { 415 SETUP_STORE_DATA_PARAM(dev, attr); 416 long reqval, i, f; 417 s8 temp; 418 419 if (kstrtol(buf, 10, &reqval)) 420 return -EINVAL; 421 422 reqval = clamp_val(reqval, -32000, 31750); 423 i = reqval / 1000; 424 f = reqval - (i * 1000); 425 temp = i << 2; 426 temp |= f / 250; 427 428 mutex_lock(&data->update_lock); 429 data->reg[param->msb[0]] = temp; 430 write_byte(client, param->msb[0], temp); 431 mutex_unlock(&data->update_lock); 432 return count; 433 } 434 435 /* 436 * The aSC7621 doesn't provide an "auto_point2". Instead, you 437 * specify the auto_point1 and a range. To keep with the sysfs 438 * hwmon specs, we synthesize the auto_point_2 from them. 439 */ 440 441 static const u32 asc7621_range_map[] = { 442 2000, 2500, 3330, 4000, 5000, 6670, 8000, 10000, 443 13330, 16000, 20000, 26670, 32000, 40000, 53330, 80000, 444 }; 445 446 static ssize_t show_ap2_temp(struct device *dev, 447 struct device_attribute *attr, char *buf) 448 { 449 SETUP_SHOW_DATA_PARAM(dev, attr); 450 long auto_point1; 451 u8 regval; 452 int temp; 453 454 mutex_lock(&data->update_lock); 455 auto_point1 = ((s8) data->reg[param->msb[1]]) * 1000; 456 regval = 457 ((data->reg[param->msb[0]] >> param->shift[0]) & param->mask[0]); 458 temp = auto_point1 + asc7621_range_map[clamp_val(regval, 0, 15)]; 459 mutex_unlock(&data->update_lock); 460 461 return sprintf(buf, "%d\n", temp); 462 463 } 464 465 static ssize_t store_ap2_temp(struct device *dev, 466 struct device_attribute *attr, 467 const char *buf, size_t count) 468 { 469 SETUP_STORE_DATA_PARAM(dev, attr); 470 long reqval, auto_point1; 471 int i; 472 u8 currval, newval = 0; 473 474 if (kstrtol(buf, 10, &reqval)) 475 return -EINVAL; 476 477 mutex_lock(&data->update_lock); 478 auto_point1 = data->reg[param->msb[1]] * 1000; 479 reqval = clamp_val(reqval, auto_point1 + 2000, auto_point1 + 80000); 480 481 for (i = ARRAY_SIZE(asc7621_range_map) - 1; i >= 0; i--) { 482 if (reqval >= auto_point1 + asc7621_range_map[i]) { 483 newval = i; 484 break; 485 } 486 } 487 488 newval = (newval & param->mask[0]) << param->shift[0]; 489 currval = read_byte(client, param->msb[0]); 490 newval |= (currval & ~(param->mask[0] << param->shift[0])); 491 data->reg[param->msb[0]] = newval; 492 write_byte(client, param->msb[0], newval); 493 mutex_unlock(&data->update_lock); 494 return count; 495 } 496 497 static ssize_t show_pwm_ac(struct device *dev, 498 struct device_attribute *attr, char *buf) 499 { 500 SETUP_SHOW_DATA_PARAM(dev, attr); 501 u8 config, altbit, regval; 502 static const u8 map[] = { 503 0x01, 0x02, 0x04, 0x1f, 0x00, 0x06, 0x07, 0x10, 504 0x08, 0x0f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f 505 }; 506 507 mutex_lock(&data->update_lock); 508 config = (data->reg[param->msb[0]] >> param->shift[0]) & param->mask[0]; 509 altbit = (data->reg[param->msb[1]] >> param->shift[1]) & param->mask[1]; 510 regval = config | (altbit << 3); 511 mutex_unlock(&data->update_lock); 512 513 return sprintf(buf, "%u\n", map[clamp_val(regval, 0, 15)]); 514 } 515 516 static ssize_t store_pwm_ac(struct device *dev, 517 struct device_attribute *attr, 518 const char *buf, size_t count) 519 { 520 SETUP_STORE_DATA_PARAM(dev, attr); 521 unsigned long reqval; 522 u8 currval, config, altbit, newval; 523 static const u16 map[] = { 524 0x04, 0x00, 0x01, 0xff, 0x02, 0xff, 0x05, 0x06, 525 0x08, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0f, 526 0x07, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 527 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 528 }; 529 530 if (kstrtoul(buf, 10, &reqval)) 531 return -EINVAL; 532 533 if (reqval > 31) 534 return -EINVAL; 535 536 reqval = map[reqval]; 537 if (reqval == 0xff) 538 return -EINVAL; 539 540 config = reqval & 0x07; 541 altbit = (reqval >> 3) & 0x01; 542 543 config = (config & param->mask[0]) << param->shift[0]; 544 altbit = (altbit & param->mask[1]) << param->shift[1]; 545 546 mutex_lock(&data->update_lock); 547 currval = read_byte(client, param->msb[0]); 548 newval = config | (currval & ~(param->mask[0] << param->shift[0])); 549 newval = altbit | (newval & ~(param->mask[1] << param->shift[1])); 550 data->reg[param->msb[0]] = newval; 551 write_byte(client, param->msb[0], newval); 552 mutex_unlock(&data->update_lock); 553 return count; 554 } 555 556 static ssize_t show_pwm_enable(struct device *dev, 557 struct device_attribute *attr, char *buf) 558 { 559 SETUP_SHOW_DATA_PARAM(dev, attr); 560 u8 config, altbit, minoff, val, newval; 561 562 mutex_lock(&data->update_lock); 563 config = (data->reg[param->msb[0]] >> param->shift[0]) & param->mask[0]; 564 altbit = (data->reg[param->msb[1]] >> param->shift[1]) & param->mask[1]; 565 minoff = (data->reg[param->msb[2]] >> param->shift[2]) & param->mask[2]; 566 mutex_unlock(&data->update_lock); 567 568 val = config | (altbit << 3); 569 570 if (val == 3 || val >= 10) 571 newval = 255; 572 else if (val == 4) 573 newval = 0; 574 else if (val == 7) 575 newval = 1; 576 else if (minoff == 1) 577 newval = 2; 578 else 579 newval = 3; 580 581 return sprintf(buf, "%u\n", newval); 582 } 583 584 static ssize_t store_pwm_enable(struct device *dev, 585 struct device_attribute *attr, 586 const char *buf, size_t count) 587 { 588 SETUP_STORE_DATA_PARAM(dev, attr); 589 long reqval; 590 u8 currval, config, altbit, newval, minoff = 255; 591 592 if (kstrtol(buf, 10, &reqval)) 593 return -EINVAL; 594 595 switch (reqval) { 596 case 0: 597 newval = 0x04; 598 break; 599 case 1: 600 newval = 0x07; 601 break; 602 case 2: 603 newval = 0x00; 604 minoff = 1; 605 break; 606 case 3: 607 newval = 0x00; 608 minoff = 0; 609 break; 610 case 255: 611 newval = 0x03; 612 break; 613 default: 614 return -EINVAL; 615 } 616 617 config = newval & 0x07; 618 altbit = (newval >> 3) & 0x01; 619 620 mutex_lock(&data->update_lock); 621 config = (config & param->mask[0]) << param->shift[0]; 622 altbit = (altbit & param->mask[1]) << param->shift[1]; 623 currval = read_byte(client, param->msb[0]); 624 newval = config | (currval & ~(param->mask[0] << param->shift[0])); 625 newval = altbit | (newval & ~(param->mask[1] << param->shift[1])); 626 data->reg[param->msb[0]] = newval; 627 write_byte(client, param->msb[0], newval); 628 if (minoff < 255) { 629 minoff = (minoff & param->mask[2]) << param->shift[2]; 630 currval = read_byte(client, param->msb[2]); 631 newval = 632 minoff | (currval & ~(param->mask[2] << param->shift[2])); 633 data->reg[param->msb[2]] = newval; 634 write_byte(client, param->msb[2], newval); 635 } 636 mutex_unlock(&data->update_lock); 637 return count; 638 } 639 640 static const u32 asc7621_pwm_freq_map[] = { 641 10, 15, 23, 30, 38, 47, 62, 94, 642 23000, 24000, 25000, 26000, 27000, 28000, 29000, 30000 643 }; 644 645 static ssize_t show_pwm_freq(struct device *dev, 646 struct device_attribute *attr, char *buf) 647 { 648 SETUP_SHOW_DATA_PARAM(dev, attr); 649 u8 regval = 650 (data->reg[param->msb[0]] >> param->shift[0]) & param->mask[0]; 651 652 regval = clamp_val(regval, 0, 15); 653 654 return sprintf(buf, "%u\n", asc7621_pwm_freq_map[regval]); 655 } 656 657 static ssize_t store_pwm_freq(struct device *dev, 658 struct device_attribute *attr, 659 const char *buf, size_t count) 660 { 661 SETUP_STORE_DATA_PARAM(dev, attr); 662 unsigned long reqval; 663 u8 currval, newval = 255; 664 int i; 665 666 if (kstrtoul(buf, 10, &reqval)) 667 return -EINVAL; 668 669 for (i = 0; i < ARRAY_SIZE(asc7621_pwm_freq_map); i++) { 670 if (reqval == asc7621_pwm_freq_map[i]) { 671 newval = i; 672 break; 673 } 674 } 675 if (newval == 255) 676 return -EINVAL; 677 678 newval = (newval & param->mask[0]) << param->shift[0]; 679 680 mutex_lock(&data->update_lock); 681 currval = read_byte(client, param->msb[0]); 682 newval |= (currval & ~(param->mask[0] << param->shift[0])); 683 data->reg[param->msb[0]] = newval; 684 write_byte(client, param->msb[0], newval); 685 mutex_unlock(&data->update_lock); 686 return count; 687 } 688 689 static const u32 asc7621_pwm_auto_spinup_map[] = { 690 0, 100, 250, 400, 700, 1000, 2000, 4000 691 }; 692 693 static ssize_t show_pwm_ast(struct device *dev, 694 struct device_attribute *attr, char *buf) 695 { 696 SETUP_SHOW_DATA_PARAM(dev, attr); 697 u8 regval = 698 (data->reg[param->msb[0]] >> param->shift[0]) & param->mask[0]; 699 700 regval = clamp_val(regval, 0, 7); 701 702 return sprintf(buf, "%u\n", asc7621_pwm_auto_spinup_map[regval]); 703 704 } 705 706 static ssize_t store_pwm_ast(struct device *dev, 707 struct device_attribute *attr, 708 const char *buf, size_t count) 709 { 710 SETUP_STORE_DATA_PARAM(dev, attr); 711 long reqval; 712 u8 currval, newval = 255; 713 u32 i; 714 715 if (kstrtol(buf, 10, &reqval)) 716 return -EINVAL; 717 718 for (i = 0; i < ARRAY_SIZE(asc7621_pwm_auto_spinup_map); i++) { 719 if (reqval == asc7621_pwm_auto_spinup_map[i]) { 720 newval = i; 721 break; 722 } 723 } 724 if (newval == 255) 725 return -EINVAL; 726 727 newval = (newval & param->mask[0]) << param->shift[0]; 728 729 mutex_lock(&data->update_lock); 730 currval = read_byte(client, param->msb[0]); 731 newval |= (currval & ~(param->mask[0] << param->shift[0])); 732 data->reg[param->msb[0]] = newval; 733 write_byte(client, param->msb[0], newval); 734 mutex_unlock(&data->update_lock); 735 return count; 736 } 737 738 static const u32 asc7621_temp_smoothing_time_map[] = { 739 35000, 17600, 11800, 7000, 4400, 3000, 1600, 800 740 }; 741 742 static ssize_t show_temp_st(struct device *dev, 743 struct device_attribute *attr, char *buf) 744 { 745 SETUP_SHOW_DATA_PARAM(dev, attr); 746 u8 regval = 747 (data->reg[param->msb[0]] >> param->shift[0]) & param->mask[0]; 748 regval = clamp_val(regval, 0, 7); 749 750 return sprintf(buf, "%u\n", asc7621_temp_smoothing_time_map[regval]); 751 } 752 753 static ssize_t store_temp_st(struct device *dev, 754 struct device_attribute *attr, 755 const char *buf, size_t count) 756 { 757 SETUP_STORE_DATA_PARAM(dev, attr); 758 long reqval; 759 u8 currval, newval = 255; 760 u32 i; 761 762 if (kstrtol(buf, 10, &reqval)) 763 return -EINVAL; 764 765 for (i = 0; i < ARRAY_SIZE(asc7621_temp_smoothing_time_map); i++) { 766 if (reqval == asc7621_temp_smoothing_time_map[i]) { 767 newval = i; 768 break; 769 } 770 } 771 772 if (newval == 255) 773 return -EINVAL; 774 775 newval = (newval & param->mask[0]) << param->shift[0]; 776 777 mutex_lock(&data->update_lock); 778 currval = read_byte(client, param->msb[0]); 779 newval |= (currval & ~(param->mask[0] << param->shift[0])); 780 data->reg[param->msb[0]] = newval; 781 write_byte(client, param->msb[0], newval); 782 mutex_unlock(&data->update_lock); 783 return count; 784 } 785 786 /* 787 * End of data handlers 788 * 789 * These defines do nothing more than make the table easier 790 * to read when wrapped at column 80. 791 */ 792 793 /* 794 * Creates a variable length array inititalizer. 795 * VAA(1,3,5,7) would produce {1,3,5,7} 796 */ 797 #define VAA(args...) {args} 798 799 #define PREAD(name, n, pri, rm, rl, m, s, r) \ 800 {.sda = SENSOR_ATTR(name, S_IRUGO, show_##r, NULL, n), \ 801 .priority = pri, .msb[0] = rm, .lsb[0] = rl, .mask[0] = m, \ 802 .shift[0] = s,} 803 804 #define PWRITE(name, n, pri, rm, rl, m, s, r) \ 805 {.sda = SENSOR_ATTR(name, S_IRUGO | S_IWUSR, show_##r, store_##r, n), \ 806 .priority = pri, .msb[0] = rm, .lsb[0] = rl, .mask[0] = m, \ 807 .shift[0] = s,} 808 809 /* 810 * PWRITEM assumes that the initializers for the .msb, .lsb, .mask and .shift 811 * were created using the VAA macro. 812 */ 813 #define PWRITEM(name, n, pri, rm, rl, m, s, r) \ 814 {.sda = SENSOR_ATTR(name, S_IRUGO | S_IWUSR, show_##r, store_##r, n), \ 815 .priority = pri, .msb = rm, .lsb = rl, .mask = m, .shift = s,} 816 817 static struct asc7621_param asc7621_params[] = { 818 PREAD(in0_input, 0, PRI_HIGH, 0x20, 0x13, 0, 0, in10), 819 PREAD(in1_input, 1, PRI_HIGH, 0x21, 0x18, 0, 0, in10), 820 PREAD(in2_input, 2, PRI_HIGH, 0x22, 0x11, 0, 0, in10), 821 PREAD(in3_input, 3, PRI_HIGH, 0x23, 0x12, 0, 0, in10), 822 PREAD(in4_input, 4, PRI_HIGH, 0x24, 0x14, 0, 0, in10), 823 824 PWRITE(in0_min, 0, PRI_LOW, 0x44, 0, 0, 0, in8), 825 PWRITE(in1_min, 1, PRI_LOW, 0x46, 0, 0, 0, in8), 826 PWRITE(in2_min, 2, PRI_LOW, 0x48, 0, 0, 0, in8), 827 PWRITE(in3_min, 3, PRI_LOW, 0x4a, 0, 0, 0, in8), 828 PWRITE(in4_min, 4, PRI_LOW, 0x4c, 0, 0, 0, in8), 829 830 PWRITE(in0_max, 0, PRI_LOW, 0x45, 0, 0, 0, in8), 831 PWRITE(in1_max, 1, PRI_LOW, 0x47, 0, 0, 0, in8), 832 PWRITE(in2_max, 2, PRI_LOW, 0x49, 0, 0, 0, in8), 833 PWRITE(in3_max, 3, PRI_LOW, 0x4b, 0, 0, 0, in8), 834 PWRITE(in4_max, 4, PRI_LOW, 0x4d, 0, 0, 0, in8), 835 836 PREAD(in0_alarm, 0, PRI_HIGH, 0x41, 0, 0x01, 0, bitmask), 837 PREAD(in1_alarm, 1, PRI_HIGH, 0x41, 0, 0x01, 1, bitmask), 838 PREAD(in2_alarm, 2, PRI_HIGH, 0x41, 0, 0x01, 2, bitmask), 839 PREAD(in3_alarm, 3, PRI_HIGH, 0x41, 0, 0x01, 3, bitmask), 840 PREAD(in4_alarm, 4, PRI_HIGH, 0x42, 0, 0x01, 0, bitmask), 841 842 PREAD(fan1_input, 0, PRI_HIGH, 0x29, 0x28, 0, 0, fan16), 843 PREAD(fan2_input, 1, PRI_HIGH, 0x2b, 0x2a, 0, 0, fan16), 844 PREAD(fan3_input, 2, PRI_HIGH, 0x2d, 0x2c, 0, 0, fan16), 845 PREAD(fan4_input, 3, PRI_HIGH, 0x2f, 0x2e, 0, 0, fan16), 846 847 PWRITE(fan1_min, 0, PRI_LOW, 0x55, 0x54, 0, 0, fan16), 848 PWRITE(fan2_min, 1, PRI_LOW, 0x57, 0x56, 0, 0, fan16), 849 PWRITE(fan3_min, 2, PRI_LOW, 0x59, 0x58, 0, 0, fan16), 850 PWRITE(fan4_min, 3, PRI_LOW, 0x5b, 0x5a, 0, 0, fan16), 851 852 PREAD(fan1_alarm, 0, PRI_HIGH, 0x42, 0, 0x01, 2, bitmask), 853 PREAD(fan2_alarm, 1, PRI_HIGH, 0x42, 0, 0x01, 3, bitmask), 854 PREAD(fan3_alarm, 2, PRI_HIGH, 0x42, 0, 0x01, 4, bitmask), 855 PREAD(fan4_alarm, 3, PRI_HIGH, 0x42, 0, 0x01, 5, bitmask), 856 857 PREAD(temp1_input, 0, PRI_HIGH, 0x25, 0x10, 0, 0, temp10), 858 PREAD(temp2_input, 1, PRI_HIGH, 0x26, 0x15, 0, 0, temp10), 859 PREAD(temp3_input, 2, PRI_HIGH, 0x27, 0x16, 0, 0, temp10), 860 PREAD(temp4_input, 3, PRI_HIGH, 0x33, 0x17, 0, 0, temp10), 861 PREAD(temp5_input, 4, PRI_HIGH, 0xf7, 0xf6, 0, 0, temp10), 862 PREAD(temp6_input, 5, PRI_HIGH, 0xf9, 0xf8, 0, 0, temp10), 863 PREAD(temp7_input, 6, PRI_HIGH, 0xfb, 0xfa, 0, 0, temp10), 864 PREAD(temp8_input, 7, PRI_HIGH, 0xfd, 0xfc, 0, 0, temp10), 865 866 PWRITE(temp1_min, 0, PRI_LOW, 0x4e, 0, 0, 0, temp8), 867 PWRITE(temp2_min, 1, PRI_LOW, 0x50, 0, 0, 0, temp8), 868 PWRITE(temp3_min, 2, PRI_LOW, 0x52, 0, 0, 0, temp8), 869 PWRITE(temp4_min, 3, PRI_LOW, 0x34, 0, 0, 0, temp8), 870 871 PWRITE(temp1_max, 0, PRI_LOW, 0x4f, 0, 0, 0, temp8), 872 PWRITE(temp2_max, 1, PRI_LOW, 0x51, 0, 0, 0, temp8), 873 PWRITE(temp3_max, 2, PRI_LOW, 0x53, 0, 0, 0, temp8), 874 PWRITE(temp4_max, 3, PRI_LOW, 0x35, 0, 0, 0, temp8), 875 876 PREAD(temp1_alarm, 0, PRI_HIGH, 0x41, 0, 0x01, 4, bitmask), 877 PREAD(temp2_alarm, 1, PRI_HIGH, 0x41, 0, 0x01, 5, bitmask), 878 PREAD(temp3_alarm, 2, PRI_HIGH, 0x41, 0, 0x01, 6, bitmask), 879 PREAD(temp4_alarm, 3, PRI_HIGH, 0x43, 0, 0x01, 0, bitmask), 880 881 PWRITE(temp1_source, 0, PRI_LOW, 0x02, 0, 0x07, 4, bitmask), 882 PWRITE(temp2_source, 1, PRI_LOW, 0x02, 0, 0x07, 0, bitmask), 883 PWRITE(temp3_source, 2, PRI_LOW, 0x03, 0, 0x07, 4, bitmask), 884 PWRITE(temp4_source, 3, PRI_LOW, 0x03, 0, 0x07, 0, bitmask), 885 886 PWRITE(temp1_smoothing_enable, 0, PRI_LOW, 0x62, 0, 0x01, 3, bitmask), 887 PWRITE(temp2_smoothing_enable, 1, PRI_LOW, 0x63, 0, 0x01, 7, bitmask), 888 PWRITE(temp3_smoothing_enable, 2, PRI_LOW, 0x63, 0, 0x01, 3, bitmask), 889 PWRITE(temp4_smoothing_enable, 3, PRI_LOW, 0x3c, 0, 0x01, 3, bitmask), 890 891 PWRITE(temp1_smoothing_time, 0, PRI_LOW, 0x62, 0, 0x07, 0, temp_st), 892 PWRITE(temp2_smoothing_time, 1, PRI_LOW, 0x63, 0, 0x07, 4, temp_st), 893 PWRITE(temp3_smoothing_time, 2, PRI_LOW, 0x63, 0, 0x07, 0, temp_st), 894 PWRITE(temp4_smoothing_time, 3, PRI_LOW, 0x3c, 0, 0x07, 0, temp_st), 895 896 PWRITE(temp1_auto_point1_temp_hyst, 0, PRI_LOW, 0x6d, 0, 0x0f, 4, 897 bitmask), 898 PWRITE(temp2_auto_point1_temp_hyst, 1, PRI_LOW, 0x6d, 0, 0x0f, 0, 899 bitmask), 900 PWRITE(temp3_auto_point1_temp_hyst, 2, PRI_LOW, 0x6e, 0, 0x0f, 4, 901 bitmask), 902 PWRITE(temp4_auto_point1_temp_hyst, 3, PRI_LOW, 0x6e, 0, 0x0f, 0, 903 bitmask), 904 905 PREAD(temp1_auto_point2_temp_hyst, 0, PRI_LOW, 0x6d, 0, 0x0f, 4, 906 bitmask), 907 PREAD(temp2_auto_point2_temp_hyst, 1, PRI_LOW, 0x6d, 0, 0x0f, 0, 908 bitmask), 909 PREAD(temp3_auto_point2_temp_hyst, 2, PRI_LOW, 0x6e, 0, 0x0f, 4, 910 bitmask), 911 PREAD(temp4_auto_point2_temp_hyst, 3, PRI_LOW, 0x6e, 0, 0x0f, 0, 912 bitmask), 913 914 PWRITE(temp1_auto_point1_temp, 0, PRI_LOW, 0x67, 0, 0, 0, temp8), 915 PWRITE(temp2_auto_point1_temp, 1, PRI_LOW, 0x68, 0, 0, 0, temp8), 916 PWRITE(temp3_auto_point1_temp, 2, PRI_LOW, 0x69, 0, 0, 0, temp8), 917 PWRITE(temp4_auto_point1_temp, 3, PRI_LOW, 0x3b, 0, 0, 0, temp8), 918 919 PWRITEM(temp1_auto_point2_temp, 0, PRI_LOW, VAA(0x5f, 0x67), VAA(0), 920 VAA(0x0f), VAA(4), ap2_temp), 921 PWRITEM(temp2_auto_point2_temp, 1, PRI_LOW, VAA(0x60, 0x68), VAA(0), 922 VAA(0x0f), VAA(4), ap2_temp), 923 PWRITEM(temp3_auto_point2_temp, 2, PRI_LOW, VAA(0x61, 0x69), VAA(0), 924 VAA(0x0f), VAA(4), ap2_temp), 925 PWRITEM(temp4_auto_point2_temp, 3, PRI_LOW, VAA(0x3c, 0x3b), VAA(0), 926 VAA(0x0f), VAA(4), ap2_temp), 927 928 PWRITE(temp1_crit, 0, PRI_LOW, 0x6a, 0, 0, 0, temp8), 929 PWRITE(temp2_crit, 1, PRI_LOW, 0x6b, 0, 0, 0, temp8), 930 PWRITE(temp3_crit, 2, PRI_LOW, 0x6c, 0, 0, 0, temp8), 931 PWRITE(temp4_crit, 3, PRI_LOW, 0x3d, 0, 0, 0, temp8), 932 933 PWRITE(temp5_enable, 4, PRI_LOW, 0x0e, 0, 0x01, 0, bitmask), 934 PWRITE(temp6_enable, 5, PRI_LOW, 0x0e, 0, 0x01, 1, bitmask), 935 PWRITE(temp7_enable, 6, PRI_LOW, 0x0e, 0, 0x01, 2, bitmask), 936 PWRITE(temp8_enable, 7, PRI_LOW, 0x0e, 0, 0x01, 3, bitmask), 937 938 PWRITE(remote1_offset, 0, PRI_LOW, 0x1c, 0, 0, 0, temp62), 939 PWRITE(remote2_offset, 1, PRI_LOW, 0x1d, 0, 0, 0, temp62), 940 941 PWRITE(pwm1, 0, PRI_HIGH, 0x30, 0, 0, 0, u8), 942 PWRITE(pwm2, 1, PRI_HIGH, 0x31, 0, 0, 0, u8), 943 PWRITE(pwm3, 2, PRI_HIGH, 0x32, 0, 0, 0, u8), 944 945 PWRITE(pwm1_invert, 0, PRI_LOW, 0x5c, 0, 0x01, 4, bitmask), 946 PWRITE(pwm2_invert, 1, PRI_LOW, 0x5d, 0, 0x01, 4, bitmask), 947 PWRITE(pwm3_invert, 2, PRI_LOW, 0x5e, 0, 0x01, 4, bitmask), 948 949 PWRITEM(pwm1_enable, 0, PRI_LOW, VAA(0x5c, 0x5c, 0x62), VAA(0, 0, 0), 950 VAA(0x07, 0x01, 0x01), VAA(5, 3, 5), pwm_enable), 951 PWRITEM(pwm2_enable, 1, PRI_LOW, VAA(0x5d, 0x5d, 0x62), VAA(0, 0, 0), 952 VAA(0x07, 0x01, 0x01), VAA(5, 3, 6), pwm_enable), 953 PWRITEM(pwm3_enable, 2, PRI_LOW, VAA(0x5e, 0x5e, 0x62), VAA(0, 0, 0), 954 VAA(0x07, 0x01, 0x01), VAA(5, 3, 7), pwm_enable), 955 956 PWRITEM(pwm1_auto_channels, 0, PRI_LOW, VAA(0x5c, 0x5c), VAA(0, 0), 957 VAA(0x07, 0x01), VAA(5, 3), pwm_ac), 958 PWRITEM(pwm2_auto_channels, 1, PRI_LOW, VAA(0x5d, 0x5d), VAA(0, 0), 959 VAA(0x07, 0x01), VAA(5, 3), pwm_ac), 960 PWRITEM(pwm3_auto_channels, 2, PRI_LOW, VAA(0x5e, 0x5e), VAA(0, 0), 961 VAA(0x07, 0x01), VAA(5, 3), pwm_ac), 962 963 PWRITE(pwm1_auto_point1_pwm, 0, PRI_LOW, 0x64, 0, 0, 0, u8), 964 PWRITE(pwm2_auto_point1_pwm, 1, PRI_LOW, 0x65, 0, 0, 0, u8), 965 PWRITE(pwm3_auto_point1_pwm, 2, PRI_LOW, 0x66, 0, 0, 0, u8), 966 967 PWRITE(pwm1_auto_point2_pwm, 0, PRI_LOW, 0x38, 0, 0, 0, u8), 968 PWRITE(pwm2_auto_point2_pwm, 1, PRI_LOW, 0x39, 0, 0, 0, u8), 969 PWRITE(pwm3_auto_point2_pwm, 2, PRI_LOW, 0x3a, 0, 0, 0, u8), 970 971 PWRITE(pwm1_freq, 0, PRI_LOW, 0x5f, 0, 0x0f, 0, pwm_freq), 972 PWRITE(pwm2_freq, 1, PRI_LOW, 0x60, 0, 0x0f, 0, pwm_freq), 973 PWRITE(pwm3_freq, 2, PRI_LOW, 0x61, 0, 0x0f, 0, pwm_freq), 974 975 PREAD(pwm1_auto_zone_assigned, 0, PRI_LOW, 0, 0, 0x03, 2, bitmask), 976 PREAD(pwm2_auto_zone_assigned, 1, PRI_LOW, 0, 0, 0x03, 4, bitmask), 977 PREAD(pwm3_auto_zone_assigned, 2, PRI_LOW, 0, 0, 0x03, 6, bitmask), 978 979 PWRITE(pwm1_auto_spinup_time, 0, PRI_LOW, 0x5c, 0, 0x07, 0, pwm_ast), 980 PWRITE(pwm2_auto_spinup_time, 1, PRI_LOW, 0x5d, 0, 0x07, 0, pwm_ast), 981 PWRITE(pwm3_auto_spinup_time, 2, PRI_LOW, 0x5e, 0, 0x07, 0, pwm_ast), 982 983 PWRITE(peci_enable, 0, PRI_LOW, 0x40, 0, 0x01, 4, bitmask), 984 PWRITE(peci_avg, 0, PRI_LOW, 0x36, 0, 0x07, 0, bitmask), 985 PWRITE(peci_domain, 0, PRI_LOW, 0x36, 0, 0x01, 3, bitmask), 986 PWRITE(peci_legacy, 0, PRI_LOW, 0x36, 0, 0x01, 4, bitmask), 987 PWRITE(peci_diode, 0, PRI_LOW, 0x0e, 0, 0x07, 4, bitmask), 988 PWRITE(peci_4domain, 0, PRI_LOW, 0x0e, 0, 0x01, 4, bitmask), 989 990 }; 991 992 static struct asc7621_data *asc7621_update_device(struct device *dev) 993 { 994 struct i2c_client *client = to_i2c_client(dev); 995 struct asc7621_data *data = i2c_get_clientdata(client); 996 int i; 997 998 /* 999 * The asc7621 chips guarantee consistent reads of multi-byte values 1000 * regardless of the order of the reads. No special logic is needed 1001 * so we can just read the registers in whatever order they appear 1002 * in the asc7621_params array. 1003 */ 1004 1005 mutex_lock(&data->update_lock); 1006 1007 /* Read all the high priority registers */ 1008 1009 if (!data->valid || 1010 time_after(jiffies, data->last_high_reading + INTERVAL_HIGH)) { 1011 1012 for (i = 0; i < ARRAY_SIZE(asc7621_register_priorities); i++) { 1013 if (asc7621_register_priorities[i] == PRI_HIGH) { 1014 data->reg[i] = 1015 i2c_smbus_read_byte_data(client, i) & 0xff; 1016 } 1017 } 1018 data->last_high_reading = jiffies; 1019 } /* last_reading */ 1020 1021 /* Read all the low priority registers. */ 1022 1023 if (!data->valid || 1024 time_after(jiffies, data->last_low_reading + INTERVAL_LOW)) { 1025 1026 for (i = 0; i < ARRAY_SIZE(asc7621_params); i++) { 1027 if (asc7621_register_priorities[i] == PRI_LOW) { 1028 data->reg[i] = 1029 i2c_smbus_read_byte_data(client, i) & 0xff; 1030 } 1031 } 1032 data->last_low_reading = jiffies; 1033 } /* last_reading */ 1034 1035 data->valid = 1; 1036 1037 mutex_unlock(&data->update_lock); 1038 1039 return data; 1040 } 1041 1042 /* 1043 * Standard detection and initialization below 1044 * 1045 * Helper function that checks if an address is valid 1046 * for a particular chip. 1047 */ 1048 1049 static inline int valid_address_for_chip(int chip_type, int address) 1050 { 1051 int i; 1052 1053 for (i = 0; asc7621_chips[chip_type].addresses[i] != I2C_CLIENT_END; 1054 i++) { 1055 if (asc7621_chips[chip_type].addresses[i] == address) 1056 return 1; 1057 } 1058 return 0; 1059 } 1060 1061 static void asc7621_init_client(struct i2c_client *client) 1062 { 1063 int value; 1064 1065 /* Warn if part was not "READY" */ 1066 1067 value = read_byte(client, 0x40); 1068 1069 if (value & 0x02) { 1070 dev_err(&client->dev, 1071 "Client (%d,0x%02x) config is locked.\n", 1072 i2c_adapter_id(client->adapter), client->addr); 1073 } 1074 if (!(value & 0x04)) { 1075 dev_err(&client->dev, "Client (%d,0x%02x) is not ready.\n", 1076 i2c_adapter_id(client->adapter), client->addr); 1077 } 1078 1079 /* 1080 * Start monitoring 1081 * 1082 * Try to clear LOCK, Set START, save everything else 1083 */ 1084 value = (value & ~0x02) | 0x01; 1085 write_byte(client, 0x40, value & 0xff); 1086 1087 } 1088 1089 static int 1090 asc7621_probe(struct i2c_client *client, const struct i2c_device_id *id) 1091 { 1092 struct asc7621_data *data; 1093 int i, err; 1094 1095 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA)) 1096 return -EIO; 1097 1098 data = devm_kzalloc(&client->dev, sizeof(struct asc7621_data), 1099 GFP_KERNEL); 1100 if (data == NULL) 1101 return -ENOMEM; 1102 1103 i2c_set_clientdata(client, data); 1104 mutex_init(&data->update_lock); 1105 1106 /* Initialize the asc7621 chip */ 1107 asc7621_init_client(client); 1108 1109 /* Create the sysfs entries */ 1110 for (i = 0; i < ARRAY_SIZE(asc7621_params); i++) { 1111 err = 1112 device_create_file(&client->dev, 1113 &(asc7621_params[i].sda.dev_attr)); 1114 if (err) 1115 goto exit_remove; 1116 } 1117 1118 data->class_dev = hwmon_device_register(&client->dev); 1119 if (IS_ERR(data->class_dev)) { 1120 err = PTR_ERR(data->class_dev); 1121 goto exit_remove; 1122 } 1123 1124 return 0; 1125 1126 exit_remove: 1127 for (i = 0; i < ARRAY_SIZE(asc7621_params); i++) { 1128 device_remove_file(&client->dev, 1129 &(asc7621_params[i].sda.dev_attr)); 1130 } 1131 1132 return err; 1133 } 1134 1135 static int asc7621_detect(struct i2c_client *client, 1136 struct i2c_board_info *info) 1137 { 1138 struct i2c_adapter *adapter = client->adapter; 1139 int company, verstep, chip_index; 1140 1141 if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) 1142 return -ENODEV; 1143 1144 for (chip_index = FIRST_CHIP; chip_index <= LAST_CHIP; chip_index++) { 1145 1146 if (!valid_address_for_chip(chip_index, client->addr)) 1147 continue; 1148 1149 company = read_byte(client, 1150 asc7621_chips[chip_index].company_reg); 1151 verstep = read_byte(client, 1152 asc7621_chips[chip_index].verstep_reg); 1153 1154 if (company == asc7621_chips[chip_index].company_id && 1155 verstep == asc7621_chips[chip_index].verstep_id) { 1156 strlcpy(info->type, asc7621_chips[chip_index].name, 1157 I2C_NAME_SIZE); 1158 1159 dev_info(&adapter->dev, "Matched %s at 0x%02x\n", 1160 asc7621_chips[chip_index].name, client->addr); 1161 return 0; 1162 } 1163 } 1164 1165 return -ENODEV; 1166 } 1167 1168 static int asc7621_remove(struct i2c_client *client) 1169 { 1170 struct asc7621_data *data = i2c_get_clientdata(client); 1171 int i; 1172 1173 hwmon_device_unregister(data->class_dev); 1174 1175 for (i = 0; i < ARRAY_SIZE(asc7621_params); i++) { 1176 device_remove_file(&client->dev, 1177 &(asc7621_params[i].sda.dev_attr)); 1178 } 1179 1180 return 0; 1181 } 1182 1183 static const struct i2c_device_id asc7621_id[] = { 1184 {"asc7621", asc7621}, 1185 {"asc7621a", asc7621a}, 1186 {}, 1187 }; 1188 1189 MODULE_DEVICE_TABLE(i2c, asc7621_id); 1190 1191 static struct i2c_driver asc7621_driver = { 1192 .class = I2C_CLASS_HWMON, 1193 .driver = { 1194 .name = "asc7621", 1195 }, 1196 .probe = asc7621_probe, 1197 .remove = asc7621_remove, 1198 .id_table = asc7621_id, 1199 .detect = asc7621_detect, 1200 .address_list = normal_i2c, 1201 }; 1202 1203 static int __init sm_asc7621_init(void) 1204 { 1205 int i, j; 1206 /* 1207 * Collect all the registers needed into a single array. 1208 * This way, if a register isn't actually used for anything, 1209 * we don't retrieve it. 1210 */ 1211 1212 for (i = 0; i < ARRAY_SIZE(asc7621_params); i++) { 1213 for (j = 0; j < ARRAY_SIZE(asc7621_params[i].msb); j++) 1214 asc7621_register_priorities[asc7621_params[i].msb[j]] = 1215 asc7621_params[i].priority; 1216 for (j = 0; j < ARRAY_SIZE(asc7621_params[i].lsb); j++) 1217 asc7621_register_priorities[asc7621_params[i].lsb[j]] = 1218 asc7621_params[i].priority; 1219 } 1220 return i2c_add_driver(&asc7621_driver); 1221 } 1222 1223 static void __exit sm_asc7621_exit(void) 1224 { 1225 i2c_del_driver(&asc7621_driver); 1226 } 1227 1228 MODULE_LICENSE("GPL"); 1229 MODULE_AUTHOR("George Joseph"); 1230 MODULE_DESCRIPTION("Andigilog aSC7621 and aSC7621a driver"); 1231 1232 module_init(sm_asc7621_init); 1233 module_exit(sm_asc7621_exit); 1234