Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
asc7621.c
Go to the documentation of this file.
1 /*
2  * asc7621.c - Part of lm_sensors, Linux kernel modules for hardware monitoring
3  * Copyright (c) 2007, 2010 George Joseph <[email protected]>
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 
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;
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 {
91  struct device *class_dev;
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  */
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  */
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 = SENSORS_LIMIT(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 = SENSORS_LIMIT(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 : SENSORS_LIMIT(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 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 = SENSORS_LIMIT(reqval, 0, 0xffff);
347 
348  reqval = reqval * 0xc0 / asc7621_in_scaling[nr];
349 
350  reqval = SENSORS_LIMIT(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 = SENSORS_LIMIT(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 = SENSORS_LIMIT(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 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[SENSORS_LIMIT(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 = SENSORS_LIMIT(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  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[SENSORS_LIMIT(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  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  newval = 0;
583 
584  if (val == 3 || val >= 10)
585  newval = 255;
586  else if (val == 4)
587  newval = 0;
588  else if (val == 7)
589  newval = 1;
590  else if (minoff == 1)
591  newval = 2;
592  else
593  newval = 3;
594 
595  return sprintf(buf, "%u\n", newval);
596 }
597 
598 static ssize_t store_pwm_enable(struct device *dev,
599  struct device_attribute *attr,
600  const char *buf, size_t count)
601 {
602  SETUP_STORE_data_param(dev, attr);
603  long reqval;
604  u8 currval, config, altbit, newval, minoff = 255;
605 
606  if (kstrtol(buf, 10, &reqval))
607  return -EINVAL;
608 
609  switch (reqval) {
610  case 0:
611  newval = 0x04;
612  break;
613  case 1:
614  newval = 0x07;
615  break;
616  case 2:
617  newval = 0x00;
618  minoff = 1;
619  break;
620  case 3:
621  newval = 0x00;
622  minoff = 0;
623  break;
624  case 255:
625  newval = 0x03;
626  break;
627  default:
628  return -EINVAL;
629  }
630 
631  config = newval & 0x07;
632  altbit = (newval >> 3) & 0x01;
633 
634  mutex_lock(&data->update_lock);
635  config = (config & param->mask[0]) << param->shift[0];
636  altbit = (altbit & param->mask[1]) << param->shift[1];
637  currval = read_byte(client, param->msb[0]);
638  newval = config | (currval & ~(param->mask[0] << param->shift[0]));
639  newval = altbit | (newval & ~(param->mask[1] << param->shift[1]));
640  data->reg[param->msb[0]] = newval;
641  write_byte(client, param->msb[0], newval);
642  if (minoff < 255) {
643  minoff = (minoff & param->mask[2]) << param->shift[2];
644  currval = read_byte(client, param->msb[2]);
645  newval =
646  minoff | (currval & ~(param->mask[2] << param->shift[2]));
647  data->reg[param->msb[2]] = newval;
648  write_byte(client, param->msb[2], newval);
649  }
650  mutex_unlock(&data->update_lock);
651  return count;
652 }
653 
654 static u32 asc7621_pwm_freq_map[] = {
655  10, 15, 23, 30, 38, 47, 62, 94,
656  23000, 24000, 25000, 26000, 27000, 28000, 29000, 30000
657 };
658 
659 static ssize_t show_pwm_freq(struct device *dev,
660  struct device_attribute *attr, char *buf)
661 {
662  SETUP_SHOW_data_param(dev, attr);
663  u8 regval =
664  (data->reg[param->msb[0]] >> param->shift[0]) & param->mask[0];
665 
666  regval = SENSORS_LIMIT(regval, 0, 15);
667 
668  return sprintf(buf, "%u\n", asc7621_pwm_freq_map[regval]);
669 }
670 
671 static ssize_t store_pwm_freq(struct device *dev,
672  struct device_attribute *attr,
673  const char *buf, size_t count)
674 {
675  SETUP_STORE_data_param(dev, attr);
676  unsigned long reqval;
677  u8 currval, newval = 255;
678  int i;
679 
680  if (kstrtoul(buf, 10, &reqval))
681  return -EINVAL;
682 
683  for (i = 0; i < ARRAY_SIZE(asc7621_pwm_freq_map); i++) {
684  if (reqval == asc7621_pwm_freq_map[i]) {
685  newval = i;
686  break;
687  }
688  }
689  if (newval == 255)
690  return -EINVAL;
691 
692  newval = (newval & param->mask[0]) << param->shift[0];
693 
694  mutex_lock(&data->update_lock);
695  currval = read_byte(client, param->msb[0]);
696  newval |= (currval & ~(param->mask[0] << param->shift[0]));
697  data->reg[param->msb[0]] = newval;
698  write_byte(client, param->msb[0], newval);
699  mutex_unlock(&data->update_lock);
700  return count;
701 }
702 
703 static u32 asc7621_pwm_auto_spinup_map[] = {
704  0, 100, 250, 400, 700, 1000, 2000, 4000
705 };
706 
707 static ssize_t show_pwm_ast(struct device *dev,
708  struct device_attribute *attr, char *buf)
709 {
710  SETUP_SHOW_data_param(dev, attr);
711  u8 regval =
712  (data->reg[param->msb[0]] >> param->shift[0]) & param->mask[0];
713 
714  regval = SENSORS_LIMIT(regval, 0, 7);
715 
716  return sprintf(buf, "%u\n", asc7621_pwm_auto_spinup_map[regval]);
717 
718 }
719 
720 static ssize_t store_pwm_ast(struct device *dev,
721  struct device_attribute *attr,
722  const char *buf, size_t count)
723 {
724  SETUP_STORE_data_param(dev, attr);
725  long reqval;
726  u8 currval, newval = 255;
727  u32 i;
728 
729  if (kstrtol(buf, 10, &reqval))
730  return -EINVAL;
731 
732  for (i = 0; i < ARRAY_SIZE(asc7621_pwm_auto_spinup_map); i++) {
733  if (reqval == asc7621_pwm_auto_spinup_map[i]) {
734  newval = i;
735  break;
736  }
737  }
738  if (newval == 255)
739  return -EINVAL;
740 
741  newval = (newval & param->mask[0]) << param->shift[0];
742 
743  mutex_lock(&data->update_lock);
744  currval = read_byte(client, param->msb[0]);
745  newval |= (currval & ~(param->mask[0] << param->shift[0]));
746  data->reg[param->msb[0]] = newval;
747  write_byte(client, param->msb[0], newval);
748  mutex_unlock(&data->update_lock);
749  return count;
750 }
751 
752 static u32 asc7621_temp_smoothing_time_map[] = {
753  35000, 17600, 11800, 7000, 4400, 3000, 1600, 800
754 };
755 
756 static ssize_t show_temp_st(struct device *dev,
757  struct device_attribute *attr, char *buf)
758 {
759  SETUP_SHOW_data_param(dev, attr);
760  u8 regval =
761  (data->reg[param->msb[0]] >> param->shift[0]) & param->mask[0];
762  regval = SENSORS_LIMIT(regval, 0, 7);
763 
764  return sprintf(buf, "%u\n", asc7621_temp_smoothing_time_map[regval]);
765 }
766 
767 static ssize_t store_temp_st(struct device *dev,
768  struct device_attribute *attr,
769  const char *buf, size_t count)
770 {
771  SETUP_STORE_data_param(dev, attr);
772  long reqval;
773  u8 currval, newval = 255;
774  u32 i;
775 
776  if (kstrtol(buf, 10, &reqval))
777  return -EINVAL;
778 
779  for (i = 0; i < ARRAY_SIZE(asc7621_temp_smoothing_time_map); i++) {
780  if (reqval == asc7621_temp_smoothing_time_map[i]) {
781  newval = i;
782  break;
783  }
784  }
785 
786  if (newval == 255)
787  return -EINVAL;
788 
789  newval = (newval & param->mask[0]) << param->shift[0];
790 
791  mutex_lock(&data->update_lock);
792  currval = read_byte(client, param->msb[0]);
793  newval |= (currval & ~(param->mask[0] << param->shift[0]));
794  data->reg[param->msb[0]] = newval;
795  write_byte(client, param->msb[0], newval);
796  mutex_unlock(&data->update_lock);
797  return count;
798 }
799 
800 /*
801  * End of data handlers
802  *
803  * These defines do nothing more than make the table easier
804  * to read when wrapped at column 80.
805  */
806 
807 /*
808  * Creates a variable length array inititalizer.
809  * VAA(1,3,5,7) would produce {1,3,5,7}
810  */
811 #define VAA(args...) {args}
812 
813 #define PREAD(name, n, pri, rm, rl, m, s, r) \
814  {.sda = SENSOR_ATTR(name, S_IRUGO, show_##r, NULL, n), \
815  .priority = pri, .msb[0] = rm, .lsb[0] = rl, .mask[0] = m, \
816  .shift[0] = s,}
817 
818 #define PWRITE(name, n, pri, rm, rl, m, s, r) \
819  {.sda = SENSOR_ATTR(name, S_IRUGO | S_IWUSR, show_##r, store_##r, n), \
820  .priority = pri, .msb[0] = rm, .lsb[0] = rl, .mask[0] = m, \
821  .shift[0] = s,}
822 
823 /*
824  * PWRITEM assumes that the initializers for the .msb, .lsb, .mask and .shift
825  * were created using the VAA macro.
826  */
827 #define PWRITEM(name, n, pri, rm, rl, m, s, r) \
828  {.sda = SENSOR_ATTR(name, S_IRUGO | S_IWUSR, show_##r, store_##r, n), \
829  .priority = pri, .msb = rm, .lsb = rl, .mask = m, .shift = s,}
830 
831 static struct asc7621_param asc7621_params[] = {
832  PREAD(in0_input, 0, PRI_HIGH, 0x20, 0x13, 0, 0, in10),
833  PREAD(in1_input, 1, PRI_HIGH, 0x21, 0x18, 0, 0, in10),
834  PREAD(in2_input, 2, PRI_HIGH, 0x22, 0x11, 0, 0, in10),
835  PREAD(in3_input, 3, PRI_HIGH, 0x23, 0x12, 0, 0, in10),
836  PREAD(in4_input, 4, PRI_HIGH, 0x24, 0x14, 0, 0, in10),
837 
838  PWRITE(in0_min, 0, PRI_LOW, 0x44, 0, 0, 0, in8),
839  PWRITE(in1_min, 1, PRI_LOW, 0x46, 0, 0, 0, in8),
840  PWRITE(in2_min, 2, PRI_LOW, 0x48, 0, 0, 0, in8),
841  PWRITE(in3_min, 3, PRI_LOW, 0x4a, 0, 0, 0, in8),
842  PWRITE(in4_min, 4, PRI_LOW, 0x4c, 0, 0, 0, in8),
843 
844  PWRITE(in0_max, 0, PRI_LOW, 0x45, 0, 0, 0, in8),
845  PWRITE(in1_max, 1, PRI_LOW, 0x47, 0, 0, 0, in8),
846  PWRITE(in2_max, 2, PRI_LOW, 0x49, 0, 0, 0, in8),
847  PWRITE(in3_max, 3, PRI_LOW, 0x4b, 0, 0, 0, in8),
848  PWRITE(in4_max, 4, PRI_LOW, 0x4d, 0, 0, 0, in8),
849 
850  PREAD(in0_alarm, 0, PRI_HIGH, 0x41, 0, 0x01, 0, bitmask),
851  PREAD(in1_alarm, 1, PRI_HIGH, 0x41, 0, 0x01, 1, bitmask),
852  PREAD(in2_alarm, 2, PRI_HIGH, 0x41, 0, 0x01, 2, bitmask),
853  PREAD(in3_alarm, 3, PRI_HIGH, 0x41, 0, 0x01, 3, bitmask),
854  PREAD(in4_alarm, 4, PRI_HIGH, 0x42, 0, 0x01, 0, bitmask),
855 
856  PREAD(fan1_input, 0, PRI_HIGH, 0x29, 0x28, 0, 0, fan16),
857  PREAD(fan2_input, 1, PRI_HIGH, 0x2b, 0x2a, 0, 0, fan16),
858  PREAD(fan3_input, 2, PRI_HIGH, 0x2d, 0x2c, 0, 0, fan16),
859  PREAD(fan4_input, 3, PRI_HIGH, 0x2f, 0x2e, 0, 0, fan16),
860 
861  PWRITE(fan1_min, 0, PRI_LOW, 0x55, 0x54, 0, 0, fan16),
862  PWRITE(fan2_min, 1, PRI_LOW, 0x57, 0x56, 0, 0, fan16),
863  PWRITE(fan3_min, 2, PRI_LOW, 0x59, 0x58, 0, 0, fan16),
864  PWRITE(fan4_min, 3, PRI_LOW, 0x5b, 0x5a, 0, 0, fan16),
865 
866  PREAD(fan1_alarm, 0, PRI_HIGH, 0x42, 0, 0x01, 2, bitmask),
867  PREAD(fan2_alarm, 1, PRI_HIGH, 0x42, 0, 0x01, 3, bitmask),
868  PREAD(fan3_alarm, 2, PRI_HIGH, 0x42, 0, 0x01, 4, bitmask),
869  PREAD(fan4_alarm, 3, PRI_HIGH, 0x42, 0, 0x01, 5, bitmask),
870 
871  PREAD(temp1_input, 0, PRI_HIGH, 0x25, 0x10, 0, 0, temp10),
872  PREAD(temp2_input, 1, PRI_HIGH, 0x26, 0x15, 0, 0, temp10),
873  PREAD(temp3_input, 2, PRI_HIGH, 0x27, 0x16, 0, 0, temp10),
874  PREAD(temp4_input, 3, PRI_HIGH, 0x33, 0x17, 0, 0, temp10),
875  PREAD(temp5_input, 4, PRI_HIGH, 0xf7, 0xf6, 0, 0, temp10),
876  PREAD(temp6_input, 5, PRI_HIGH, 0xf9, 0xf8, 0, 0, temp10),
877  PREAD(temp7_input, 6, PRI_HIGH, 0xfb, 0xfa, 0, 0, temp10),
878  PREAD(temp8_input, 7, PRI_HIGH, 0xfd, 0xfc, 0, 0, temp10),
879 
880  PWRITE(temp1_min, 0, PRI_LOW, 0x4e, 0, 0, 0, temp8),
881  PWRITE(temp2_min, 1, PRI_LOW, 0x50, 0, 0, 0, temp8),
882  PWRITE(temp3_min, 2, PRI_LOW, 0x52, 0, 0, 0, temp8),
883  PWRITE(temp4_min, 3, PRI_LOW, 0x34, 0, 0, 0, temp8),
884 
885  PWRITE(temp1_max, 0, PRI_LOW, 0x4f, 0, 0, 0, temp8),
886  PWRITE(temp2_max, 1, PRI_LOW, 0x51, 0, 0, 0, temp8),
887  PWRITE(temp3_max, 2, PRI_LOW, 0x53, 0, 0, 0, temp8),
888  PWRITE(temp4_max, 3, PRI_LOW, 0x35, 0, 0, 0, temp8),
889 
890  PREAD(temp1_alarm, 0, PRI_HIGH, 0x41, 0, 0x01, 4, bitmask),
891  PREAD(temp2_alarm, 1, PRI_HIGH, 0x41, 0, 0x01, 5, bitmask),
892  PREAD(temp3_alarm, 2, PRI_HIGH, 0x41, 0, 0x01, 6, bitmask),
893  PREAD(temp4_alarm, 3, PRI_HIGH, 0x43, 0, 0x01, 0, bitmask),
894 
895  PWRITE(temp1_source, 0, PRI_LOW, 0x02, 0, 0x07, 4, bitmask),
896  PWRITE(temp2_source, 1, PRI_LOW, 0x02, 0, 0x07, 0, bitmask),
897  PWRITE(temp3_source, 2, PRI_LOW, 0x03, 0, 0x07, 4, bitmask),
898  PWRITE(temp4_source, 3, PRI_LOW, 0x03, 0, 0x07, 0, bitmask),
899 
900  PWRITE(temp1_smoothing_enable, 0, PRI_LOW, 0x62, 0, 0x01, 3, bitmask),
901  PWRITE(temp2_smoothing_enable, 1, PRI_LOW, 0x63, 0, 0x01, 7, bitmask),
902  PWRITE(temp3_smoothing_enable, 2, PRI_LOW, 0x63, 0, 0x01, 3, bitmask),
903  PWRITE(temp4_smoothing_enable, 3, PRI_LOW, 0x3c, 0, 0x01, 3, bitmask),
904 
905  PWRITE(temp1_smoothing_time, 0, PRI_LOW, 0x62, 0, 0x07, 0, temp_st),
906  PWRITE(temp2_smoothing_time, 1, PRI_LOW, 0x63, 0, 0x07, 4, temp_st),
907  PWRITE(temp3_smoothing_time, 2, PRI_LOW, 0x63, 0, 0x07, 0, temp_st),
908  PWRITE(temp4_smoothing_time, 3, PRI_LOW, 0x3c, 0, 0x07, 0, temp_st),
909 
910  PWRITE(temp1_auto_point1_temp_hyst, 0, PRI_LOW, 0x6d, 0, 0x0f, 4,
911  bitmask),
912  PWRITE(temp2_auto_point1_temp_hyst, 1, PRI_LOW, 0x6d, 0, 0x0f, 0,
913  bitmask),
914  PWRITE(temp3_auto_point1_temp_hyst, 2, PRI_LOW, 0x6e, 0, 0x0f, 4,
915  bitmask),
916  PWRITE(temp4_auto_point1_temp_hyst, 3, PRI_LOW, 0x6e, 0, 0x0f, 0,
917  bitmask),
918 
919  PREAD(temp1_auto_point2_temp_hyst, 0, PRI_LOW, 0x6d, 0, 0x0f, 4,
920  bitmask),
921  PREAD(temp2_auto_point2_temp_hyst, 1, PRI_LOW, 0x6d, 0, 0x0f, 0,
922  bitmask),
923  PREAD(temp3_auto_point2_temp_hyst, 2, PRI_LOW, 0x6e, 0, 0x0f, 4,
924  bitmask),
925  PREAD(temp4_auto_point2_temp_hyst, 3, PRI_LOW, 0x6e, 0, 0x0f, 0,
926  bitmask),
927 
928  PWRITE(temp1_auto_point1_temp, 0, PRI_LOW, 0x67, 0, 0, 0, temp8),
929  PWRITE(temp2_auto_point1_temp, 1, PRI_LOW, 0x68, 0, 0, 0, temp8),
930  PWRITE(temp3_auto_point1_temp, 2, PRI_LOW, 0x69, 0, 0, 0, temp8),
931  PWRITE(temp4_auto_point1_temp, 3, PRI_LOW, 0x3b, 0, 0, 0, temp8),
932 
933  PWRITEM(temp1_auto_point2_temp, 0, PRI_LOW, VAA(0x5f, 0x67), VAA(0),
934  VAA(0x0f), VAA(4), ap2_temp),
935  PWRITEM(temp2_auto_point2_temp, 1, PRI_LOW, VAA(0x60, 0x68), VAA(0),
936  VAA(0x0f), VAA(4), ap2_temp),
937  PWRITEM(temp3_auto_point2_temp, 2, PRI_LOW, VAA(0x61, 0x69), VAA(0),
938  VAA(0x0f), VAA(4), ap2_temp),
939  PWRITEM(temp4_auto_point2_temp, 3, PRI_LOW, VAA(0x3c, 0x3b), VAA(0),
940  VAA(0x0f), VAA(4), ap2_temp),
941 
942  PWRITE(temp1_crit, 0, PRI_LOW, 0x6a, 0, 0, 0, temp8),
943  PWRITE(temp2_crit, 1, PRI_LOW, 0x6b, 0, 0, 0, temp8),
944  PWRITE(temp3_crit, 2, PRI_LOW, 0x6c, 0, 0, 0, temp8),
945  PWRITE(temp4_crit, 3, PRI_LOW, 0x3d, 0, 0, 0, temp8),
946 
947  PWRITE(temp5_enable, 4, PRI_LOW, 0x0e, 0, 0x01, 0, bitmask),
948  PWRITE(temp6_enable, 5, PRI_LOW, 0x0e, 0, 0x01, 1, bitmask),
949  PWRITE(temp7_enable, 6, PRI_LOW, 0x0e, 0, 0x01, 2, bitmask),
950  PWRITE(temp8_enable, 7, PRI_LOW, 0x0e, 0, 0x01, 3, bitmask),
951 
952  PWRITE(remote1_offset, 0, PRI_LOW, 0x1c, 0, 0, 0, temp62),
953  PWRITE(remote2_offset, 1, PRI_LOW, 0x1d, 0, 0, 0, temp62),
954 
955  PWRITE(pwm1, 0, PRI_HIGH, 0x30, 0, 0, 0, u8),
956  PWRITE(pwm2, 1, PRI_HIGH, 0x31, 0, 0, 0, u8),
957  PWRITE(pwm3, 2, PRI_HIGH, 0x32, 0, 0, 0, u8),
958 
959  PWRITE(pwm1_invert, 0, PRI_LOW, 0x5c, 0, 0x01, 4, bitmask),
960  PWRITE(pwm2_invert, 1, PRI_LOW, 0x5d, 0, 0x01, 4, bitmask),
961  PWRITE(pwm3_invert, 2, PRI_LOW, 0x5e, 0, 0x01, 4, bitmask),
962 
963  PWRITEM(pwm1_enable, 0, PRI_LOW, VAA(0x5c, 0x5c, 0x62), VAA(0, 0, 0),
964  VAA(0x07, 0x01, 0x01), VAA(5, 3, 5), pwm_enable),
965  PWRITEM(pwm2_enable, 1, PRI_LOW, VAA(0x5d, 0x5d, 0x62), VAA(0, 0, 0),
966  VAA(0x07, 0x01, 0x01), VAA(5, 3, 6), pwm_enable),
967  PWRITEM(pwm3_enable, 2, PRI_LOW, VAA(0x5e, 0x5e, 0x62), VAA(0, 0, 0),
968  VAA(0x07, 0x01, 0x01), VAA(5, 3, 7), pwm_enable),
969 
970  PWRITEM(pwm1_auto_channels, 0, PRI_LOW, VAA(0x5c, 0x5c), VAA(0, 0),
971  VAA(0x07, 0x01), VAA(5, 3), pwm_ac),
972  PWRITEM(pwm2_auto_channels, 1, PRI_LOW, VAA(0x5d, 0x5d), VAA(0, 0),
973  VAA(0x07, 0x01), VAA(5, 3), pwm_ac),
974  PWRITEM(pwm3_auto_channels, 2, PRI_LOW, VAA(0x5e, 0x5e), VAA(0, 0),
975  VAA(0x07, 0x01), VAA(5, 3), pwm_ac),
976 
977  PWRITE(pwm1_auto_point1_pwm, 0, PRI_LOW, 0x64, 0, 0, 0, u8),
978  PWRITE(pwm2_auto_point1_pwm, 1, PRI_LOW, 0x65, 0, 0, 0, u8),
979  PWRITE(pwm3_auto_point1_pwm, 2, PRI_LOW, 0x66, 0, 0, 0, u8),
980 
981  PWRITE(pwm1_auto_point2_pwm, 0, PRI_LOW, 0x38, 0, 0, 0, u8),
982  PWRITE(pwm2_auto_point2_pwm, 1, PRI_LOW, 0x39, 0, 0, 0, u8),
983  PWRITE(pwm3_auto_point2_pwm, 2, PRI_LOW, 0x3a, 0, 0, 0, u8),
984 
985  PWRITE(pwm1_freq, 0, PRI_LOW, 0x5f, 0, 0x0f, 0, pwm_freq),
986  PWRITE(pwm2_freq, 1, PRI_LOW, 0x60, 0, 0x0f, 0, pwm_freq),
987  PWRITE(pwm3_freq, 2, PRI_LOW, 0x61, 0, 0x0f, 0, pwm_freq),
988 
989  PREAD(pwm1_auto_zone_assigned, 0, PRI_LOW, 0, 0, 0x03, 2, bitmask),
990  PREAD(pwm2_auto_zone_assigned, 1, PRI_LOW, 0, 0, 0x03, 4, bitmask),
991  PREAD(pwm3_auto_zone_assigned, 2, PRI_LOW, 0, 0, 0x03, 6, bitmask),
992 
993  PWRITE(pwm1_auto_spinup_time, 0, PRI_LOW, 0x5c, 0, 0x07, 0, pwm_ast),
994  PWRITE(pwm2_auto_spinup_time, 1, PRI_LOW, 0x5d, 0, 0x07, 0, pwm_ast),
995  PWRITE(pwm3_auto_spinup_time, 2, PRI_LOW, 0x5e, 0, 0x07, 0, pwm_ast),
996 
997  PWRITE(peci_enable, 0, PRI_LOW, 0x40, 0, 0x01, 4, bitmask),
998  PWRITE(peci_avg, 0, PRI_LOW, 0x36, 0, 0x07, 0, bitmask),
999  PWRITE(peci_domain, 0, PRI_LOW, 0x36, 0, 0x01, 3, bitmask),
1000  PWRITE(peci_legacy, 0, PRI_LOW, 0x36, 0, 0x01, 4, bitmask),
1001  PWRITE(peci_diode, 0, PRI_LOW, 0x0e, 0, 0x07, 4, bitmask),
1002  PWRITE(peci_4domain, 0, PRI_LOW, 0x0e, 0, 0x01, 4, bitmask),
1003 
1004 };
1005 
1006 static struct asc7621_data *asc7621_update_device(struct device *dev)
1007 {
1008  struct i2c_client *client = to_i2c_client(dev);
1009  struct asc7621_data *data = i2c_get_clientdata(client);
1010  int i;
1011 
1012 /*
1013  * The asc7621 chips guarantee consistent reads of multi-byte values
1014  * regardless of the order of the reads. No special logic is needed
1015  * so we can just read the registers in whatever order they appear
1016  * in the asc7621_params array.
1017  */
1018 
1019  mutex_lock(&data->update_lock);
1020 
1021  /* Read all the high priority registers */
1022 
1023  if (!data->valid ||
1024  time_after(jiffies, data->last_high_reading + INTERVAL_HIGH)) {
1025 
1026  for (i = 0; i < ARRAY_SIZE(asc7621_register_priorities); i++) {
1027  if (asc7621_register_priorities[i] == PRI_HIGH) {
1028  data->reg[i] =
1029  i2c_smbus_read_byte_data(client, i) & 0xff;
1030  }
1031  }
1032  data->last_high_reading = jiffies;
1033  }; /* last_reading */
1034 
1035  /* Read all the low priority registers. */
1036 
1037  if (!data->valid ||
1038  time_after(jiffies, data->last_low_reading + INTERVAL_LOW)) {
1039 
1040  for (i = 0; i < ARRAY_SIZE(asc7621_params); i++) {
1041  if (asc7621_register_priorities[i] == PRI_LOW) {
1042  data->reg[i] =
1043  i2c_smbus_read_byte_data(client, i) & 0xff;
1044  }
1045  }
1046  data->last_low_reading = jiffies;
1047  }; /* last_reading */
1048 
1049  data->valid = 1;
1050 
1051  mutex_unlock(&data->update_lock);
1052 
1053  return data;
1054 }
1055 
1056 /*
1057  * Standard detection and initialization below
1058  *
1059  * Helper function that checks if an address is valid
1060  * for a particular chip.
1061  */
1062 
1063 static inline int valid_address_for_chip(int chip_type, int address)
1064 {
1065  int i;
1066 
1067  for (i = 0; asc7621_chips[chip_type].addresses[i] != I2C_CLIENT_END;
1068  i++) {
1069  if (asc7621_chips[chip_type].addresses[i] == address)
1070  return 1;
1071  }
1072  return 0;
1073 }
1074 
1075 static void asc7621_init_client(struct i2c_client *client)
1076 {
1077  int value;
1078 
1079  /* Warn if part was not "READY" */
1080 
1081  value = read_byte(client, 0x40);
1082 
1083  if (value & 0x02) {
1084  dev_err(&client->dev,
1085  "Client (%d,0x%02x) config is locked.\n",
1086  i2c_adapter_id(client->adapter), client->addr);
1087  };
1088  if (!(value & 0x04)) {
1089  dev_err(&client->dev, "Client (%d,0x%02x) is not ready.\n",
1090  i2c_adapter_id(client->adapter), client->addr);
1091  };
1092 
1093 /*
1094  * Start monitoring
1095  *
1096  * Try to clear LOCK, Set START, save everything else
1097  */
1098  value = (value & ~0x02) | 0x01;
1099  write_byte(client, 0x40, value & 0xff);
1100 
1101 }
1102 
1103 static int
1104 asc7621_probe(struct i2c_client *client, const struct i2c_device_id *id)
1105 {
1106  struct asc7621_data *data;
1107  int i, err;
1108 
1109  if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
1110  return -EIO;
1111 
1112  data = devm_kzalloc(&client->dev, sizeof(struct asc7621_data),
1113  GFP_KERNEL);
1114  if (data == NULL)
1115  return -ENOMEM;
1116 
1117  i2c_set_clientdata(client, data);
1118  data->valid = 0;
1119  mutex_init(&data->update_lock);
1120 
1121  /* Initialize the asc7621 chip */
1122  asc7621_init_client(client);
1123 
1124  /* Create the sysfs entries */
1125  for (i = 0; i < ARRAY_SIZE(asc7621_params); i++) {
1126  err =
1127  device_create_file(&client->dev,
1128  &(asc7621_params[i].sda.dev_attr));
1129  if (err)
1130  goto exit_remove;
1131  }
1132 
1133  data->class_dev = hwmon_device_register(&client->dev);
1134  if (IS_ERR(data->class_dev)) {
1135  err = PTR_ERR(data->class_dev);
1136  goto exit_remove;
1137  }
1138 
1139  return 0;
1140 
1141 exit_remove:
1142  for (i = 0; i < ARRAY_SIZE(asc7621_params); i++) {
1143  device_remove_file(&client->dev,
1144  &(asc7621_params[i].sda.dev_attr));
1145  }
1146 
1147  return err;
1148 }
1149 
1150 static int asc7621_detect(struct i2c_client *client,
1151  struct i2c_board_info *info)
1152 {
1153  struct i2c_adapter *adapter = client->adapter;
1154  int company, verstep, chip_index;
1155 
1156  if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
1157  return -ENODEV;
1158 
1159  for (chip_index = FIRST_CHIP; chip_index <= LAST_CHIP; chip_index++) {
1160 
1161  if (!valid_address_for_chip(chip_index, client->addr))
1162  continue;
1163 
1164  company = read_byte(client,
1165  asc7621_chips[chip_index].company_reg);
1166  verstep = read_byte(client,
1167  asc7621_chips[chip_index].verstep_reg);
1168 
1169  if (company == asc7621_chips[chip_index].company_id &&
1170  verstep == asc7621_chips[chip_index].verstep_id) {
1171  strlcpy(info->type, asc7621_chips[chip_index].name,
1172  I2C_NAME_SIZE);
1173 
1174  dev_info(&adapter->dev, "Matched %s at 0x%02x\n",
1175  asc7621_chips[chip_index].name, client->addr);
1176  return 0;
1177  }
1178  }
1179 
1180  return -ENODEV;
1181 }
1182 
1183 static int asc7621_remove(struct i2c_client *client)
1184 {
1185  struct asc7621_data *data = i2c_get_clientdata(client);
1186  int i;
1187 
1189 
1190  for (i = 0; i < ARRAY_SIZE(asc7621_params); i++) {
1191  device_remove_file(&client->dev,
1192  &(asc7621_params[i].sda.dev_attr));
1193  }
1194 
1195  return 0;
1196 }
1197 
1198 static const struct i2c_device_id asc7621_id[] = {
1199  {"asc7621", asc7621},
1200  {"asc7621a", asc7621a},
1201  {},
1202 };
1203 
1204 MODULE_DEVICE_TABLE(i2c, asc7621_id);
1205 
1206 static struct i2c_driver asc7621_driver = {
1207  .class = I2C_CLASS_HWMON,
1208  .driver = {
1209  .name = "asc7621",
1210  },
1211  .probe = asc7621_probe,
1212  .remove = asc7621_remove,
1213  .id_table = asc7621_id,
1214  .detect = asc7621_detect,
1215  .address_list = normal_i2c,
1216 };
1217 
1218 static int __init sm_asc7621_init(void)
1219 {
1220  int i, j;
1221 /*
1222  * Collect all the registers needed into a single array.
1223  * This way, if a register isn't actually used for anything,
1224  * we don't retrieve it.
1225  */
1226 
1227  for (i = 0; i < ARRAY_SIZE(asc7621_params); i++) {
1228  for (j = 0; j < ARRAY_SIZE(asc7621_params[i].msb); j++)
1229  asc7621_register_priorities[asc7621_params[i].msb[j]] =
1230  asc7621_params[i].priority;
1231  for (j = 0; j < ARRAY_SIZE(asc7621_params[i].lsb); j++)
1232  asc7621_register_priorities[asc7621_params[i].lsb[j]] =
1233  asc7621_params[i].priority;
1234  }
1235  return i2c_add_driver(&asc7621_driver);
1236 }
1237 
1238 static void __exit sm_asc7621_exit(void)
1239 {
1240  i2c_del_driver(&asc7621_driver);
1241 }
1242 
1243 MODULE_LICENSE("GPL");
1244 MODULE_AUTHOR("George Joseph");
1245 MODULE_DESCRIPTION("Andigilog aSC7621 and aSC7621a driver");
1246 
1247 module_init(sm_asc7621_init);
1248 module_exit(sm_asc7621_exit);