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 */
  18static const unsigned short normal_i2c[] = {
  19	0x2c, 0x2d, 0x2e, I2C_CLIENT_END
  20};
  21
  22enum 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
  35struct 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
  45static 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
  76struct 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 */
 104struct 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 */
 117static u8 asc7621_register_priorities[255];
 118
 119static struct asc7621_data *asc7621_update_device(struct device *dev);
 120
 121static 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
 132static 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 */
 164static 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
 172static 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 */
 193static 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
 203static 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 */
 233static 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
 248static 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
 290static const int asc7621_in_scaling[] = {
 291	2500, 2250, 3300, 5000, 12000
 292};
 293
 294static 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) */
 312static 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
 323static 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
 347static 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
 355static 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 */
 384static 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 */
 401static 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
 411static 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
 441static 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
 446static 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
 465static 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
 497static 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
 516static 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
 556static 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
 584static 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
 640static 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
 645static 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
 657static 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
 689static const u32 asc7621_pwm_auto_spinup_map[] =  {
 690	0, 100, 250, 400, 700, 1000, 2000, 4000
 691};
 692
 693static 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
 706static 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
 738static const u32 asc7621_temp_smoothing_time_map[] = {
 739	35000, 17600, 11800, 7000, 4400, 3000, 1600, 800
 740};
 741
 742static 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
 753static 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
 817static 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
 992static 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
1049static 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
1061static 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
1089static int
1090asc7621_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
1126exit_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
1135static 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
1168static 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
1183static const struct i2c_device_id asc7621_id[] = {
1184	{"asc7621", asc7621},
1185	{"asc7621a", asc7621a},
1186	{},
1187};
1188
1189MODULE_DEVICE_TABLE(i2c, asc7621_id);
1190
1191static 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
1203static 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
1223static void __exit sm_asc7621_exit(void)
1224{
1225	i2c_del_driver(&asc7621_driver);
1226}
1227
1228MODULE_LICENSE("GPL");
1229MODULE_AUTHOR("George Joseph");
1230MODULE_DESCRIPTION("Andigilog aSC7621 and aSC7621a driver");
1231
1232module_init(sm_asc7621_init);
1233module_exit(sm_asc7621_exit);