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