drivers/hwmon/asc7621.c

   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);