Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
asb100.c
Go to the documentation of this file.
1 /*
2  * asb100.c - Part of lm_sensors, Linux kernel modules for hardware
3  * monitoring
4  *
5  * Copyright (C) 2004 Mark M. Hoffman <[email protected]>
6  *
7  * (derived from w83781d.c)
8  *
9  * Copyright (C) 1998 - 2003 Frodo Looijaard <[email protected]>,
10  * Philip Edelbrock <[email protected]>, and
11  * Mark Studebaker <[email protected]>
12  *
13  * This program is free software; you can redistribute it and/or modify
14  * it under the terms of the GNU General Public License as published by
15  * the Free Software Foundation; either version 2 of the License, or
16  * (at your option) any later version.
17  *
18  * This program is distributed in the hope that it will be useful,
19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21  * GNU General Public License for more details.
22  *
23  * You should have received a copy of the GNU General Public License
24  * along with this program; if not, write to the Free Software
25  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26  */
27 
28 /*
29  * This driver supports the hardware sensor chips: Asus ASB100 and
30  * ASB100-A "BACH".
31  *
32  * ASB100-A supports pwm1, while plain ASB100 does not. There is no known
33  * way for the driver to tell which one is there.
34  *
35  * Chip #vin #fanin #pwm #temp wchipid vendid i2c ISA
36  * asb100 7 3 1 4 0x31 0x0694 yes no
37  */
38 
39 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
40 
41 #include <linux/module.h>
42 #include <linux/slab.h>
43 #include <linux/i2c.h>
44 #include <linux/hwmon.h>
45 #include <linux/hwmon-sysfs.h>
46 #include <linux/hwmon-vid.h>
47 #include <linux/err.h>
48 #include <linux/init.h>
49 #include <linux/jiffies.h>
50 #include <linux/mutex.h>
51 #include "lm75.h"
52 
53 /* I2C addresses to scan */
54 static const unsigned short normal_i2c[] = { 0x2d, I2C_CLIENT_END };
55 
56 static unsigned short force_subclients[4];
57 module_param_array(force_subclients, short, NULL, 0);
58 MODULE_PARM_DESC(force_subclients, "List of subclient addresses: "
59  "{bus, clientaddr, subclientaddr1, subclientaddr2}");
60 
61 /* Voltage IN registers 0-6 */
62 #define ASB100_REG_IN(nr) (0x20 + (nr))
63 #define ASB100_REG_IN_MAX(nr) (0x2b + (nr * 2))
64 #define ASB100_REG_IN_MIN(nr) (0x2c + (nr * 2))
65 
66 /* FAN IN registers 1-3 */
67 #define ASB100_REG_FAN(nr) (0x28 + (nr))
68 #define ASB100_REG_FAN_MIN(nr) (0x3b + (nr))
69 
70 /* TEMPERATURE registers 1-4 */
71 static const u16 asb100_reg_temp[] = {0, 0x27, 0x150, 0x250, 0x17};
72 static const u16 asb100_reg_temp_max[] = {0, 0x39, 0x155, 0x255, 0x18};
73 static const u16 asb100_reg_temp_hyst[] = {0, 0x3a, 0x153, 0x253, 0x19};
74 
75 #define ASB100_REG_TEMP(nr) (asb100_reg_temp[nr])
76 #define ASB100_REG_TEMP_MAX(nr) (asb100_reg_temp_max[nr])
77 #define ASB100_REG_TEMP_HYST(nr) (asb100_reg_temp_hyst[nr])
78 
79 #define ASB100_REG_TEMP2_CONFIG 0x0152
80 #define ASB100_REG_TEMP3_CONFIG 0x0252
81 
82 
83 #define ASB100_REG_CONFIG 0x40
84 #define ASB100_REG_ALARM1 0x41
85 #define ASB100_REG_ALARM2 0x42
86 #define ASB100_REG_SMIM1 0x43
87 #define ASB100_REG_SMIM2 0x44
88 #define ASB100_REG_VID_FANDIV 0x47
89 #define ASB100_REG_I2C_ADDR 0x48
90 #define ASB100_REG_CHIPID 0x49
91 #define ASB100_REG_I2C_SUBADDR 0x4a
92 #define ASB100_REG_PIN 0x4b
93 #define ASB100_REG_IRQ 0x4c
94 #define ASB100_REG_BANK 0x4e
95 #define ASB100_REG_CHIPMAN 0x4f
96 
97 #define ASB100_REG_WCHIPID 0x58
98 
99 /* bit 7 -> enable, bits 0-3 -> duty cycle */
100 #define ASB100_REG_PWM1 0x59
101 
102 /*
103  * CONVERSIONS
104  * Rounding and limit checking is only done on the TO_REG variants.
105  */
106 
107 /* These constants are a guess, consistent w/ w83781d */
108 #define ASB100_IN_MIN 0
109 #define ASB100_IN_MAX 4080
110 
111 /*
112  * IN: 1/1000 V (0V to 4.08V)
113  * REG: 16mV/bit
114  */
115 static u8 IN_TO_REG(unsigned val)
116 {
117  unsigned nval = SENSORS_LIMIT(val, ASB100_IN_MIN, ASB100_IN_MAX);
118  return (nval + 8) / 16;
119 }
120 
121 static unsigned IN_FROM_REG(u8 reg)
122 {
123  return reg * 16;
124 }
125 
126 static u8 FAN_TO_REG(long rpm, int div)
127 {
128  if (rpm == -1)
129  return 0;
130  if (rpm == 0)
131  return 255;
132  rpm = SENSORS_LIMIT(rpm, 1, 1000000);
133  return SENSORS_LIMIT((1350000 + rpm * div / 2) / (rpm * div), 1, 254);
134 }
135 
136 static int FAN_FROM_REG(u8 val, int div)
137 {
138  return val == 0 ? -1 : val == 255 ? 0 : 1350000 / (val * div);
139 }
140 
141 /* These constants are a guess, consistent w/ w83781d */
142 #define ASB100_TEMP_MIN -128000
143 #define ASB100_TEMP_MAX 127000
144 
145 /*
146  * TEMP: 0.001C/bit (-128C to +127C)
147  * REG: 1C/bit, two's complement
148  */
149 static u8 TEMP_TO_REG(long temp)
150 {
151  int ntemp = SENSORS_LIMIT(temp, ASB100_TEMP_MIN, ASB100_TEMP_MAX);
152  ntemp += (ntemp < 0 ? -500 : 500);
153  return (u8)(ntemp / 1000);
154 }
155 
156 static int TEMP_FROM_REG(u8 reg)
157 {
158  return (s8)reg * 1000;
159 }
160 
161 /*
162  * PWM: 0 - 255 per sensors documentation
163  * REG: (6.25% duty cycle per bit)
164  */
165 static u8 ASB100_PWM_TO_REG(int pwm)
166 {
167  pwm = SENSORS_LIMIT(pwm, 0, 255);
168  return (u8)(pwm / 16);
169 }
170 
171 static int ASB100_PWM_FROM_REG(u8 reg)
172 {
173  return reg * 16;
174 }
175 
176 #define DIV_FROM_REG(val) (1 << (val))
177 
178 /*
179  * FAN DIV: 1, 2, 4, or 8 (defaults to 2)
180  * REG: 0, 1, 2, or 3 (respectively) (defaults to 1)
181  */
182 static u8 DIV_TO_REG(long val)
183 {
184  return val == 8 ? 3 : val == 4 ? 2 : val == 1 ? 0 : 1;
185 }
186 
187 /*
188  * For each registered client, we need to keep some data in memory. That
189  * data is pointed to by client->data. The structure itself is
190  * dynamically allocated, at the same time the client itself is allocated.
191  */
192 struct asb100_data {
193  struct device *hwmon_dev;
194  struct mutex lock;
195 
197  unsigned long last_updated; /* In jiffies */
198 
199  /* array of 2 pointers to subclients */
200  struct i2c_client *lm75[2];
201 
202  char valid; /* !=0 if following fields are valid */
203  u8 in[7]; /* Register value */
204  u8 in_max[7]; /* Register value */
205  u8 in_min[7]; /* Register value */
206  u8 fan[3]; /* Register value */
207  u8 fan_min[3]; /* Register value */
208  u16 temp[4]; /* Register value (0 and 3 are u8 only) */
209  u16 temp_max[4]; /* Register value (0 and 3 are u8 only) */
210  u16 temp_hyst[4]; /* Register value (0 and 3 are u8 only) */
211  u8 fan_div[3]; /* Register encoding, right justified */
212  u8 pwm; /* Register encoding */
213  u8 vid; /* Register encoding, combined */
214  u32 alarms; /* Register encoding, combined */
216 };
217 
218 static int asb100_read_value(struct i2c_client *client, u16 reg);
219 static void asb100_write_value(struct i2c_client *client, u16 reg, u16 val);
220 
221 static int asb100_probe(struct i2c_client *client,
222  const struct i2c_device_id *id);
223 static int asb100_detect(struct i2c_client *client,
224  struct i2c_board_info *info);
225 static int asb100_remove(struct i2c_client *client);
226 static struct asb100_data *asb100_update_device(struct device *dev);
227 static void asb100_init_client(struct i2c_client *client);
228 
229 static const struct i2c_device_id asb100_id[] = {
230  { "asb100", 0 },
231  { }
232 };
233 MODULE_DEVICE_TABLE(i2c, asb100_id);
234 
235 static struct i2c_driver asb100_driver = {
236  .class = I2C_CLASS_HWMON,
237  .driver = {
238  .name = "asb100",
239  },
240  .probe = asb100_probe,
241  .remove = asb100_remove,
242  .id_table = asb100_id,
243  .detect = asb100_detect,
244  .address_list = normal_i2c,
245 };
246 
247 /* 7 Voltages */
248 #define show_in_reg(reg) \
249 static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \
250  char *buf) \
251 { \
252  int nr = to_sensor_dev_attr(attr)->index; \
253  struct asb100_data *data = asb100_update_device(dev); \
254  return sprintf(buf, "%d\n", IN_FROM_REG(data->reg[nr])); \
255 }
256 
258 show_in_reg(in_min)
259 show_in_reg(in_max)
260 
261 #define set_in_reg(REG, reg) \
262 static ssize_t set_in_##reg(struct device *dev, struct device_attribute *attr, \
263  const char *buf, size_t count) \
264 { \
265  int nr = to_sensor_dev_attr(attr)->index; \
266  struct i2c_client *client = to_i2c_client(dev); \
267  struct asb100_data *data = i2c_get_clientdata(client); \
268  unsigned long val; \
269  int err = kstrtoul(buf, 10, &val); \
270  if (err) \
271  return err; \
272  mutex_lock(&data->update_lock); \
273  data->in_##reg[nr] = IN_TO_REG(val); \
274  asb100_write_value(client, ASB100_REG_IN_##REG(nr), \
275  data->in_##reg[nr]); \
276  mutex_unlock(&data->update_lock); \
277  return count; \
278 }
279 
281 set_in_reg(MAX, max)
282 
283 #define sysfs_in(offset) \
284 static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO, \
285  show_in, NULL, offset); \
286 static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR, \
287  show_in_min, set_in_min, offset); \
288 static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR, \
289  show_in_max, set_in_max, offset)
290 
291 sysfs_in(0);
292 sysfs_in(1);
293 sysfs_in(2);
294 sysfs_in(3);
295 sysfs_in(4);
296 sysfs_in(5);
297 sysfs_in(6);
298 
299 /* 3 Fans */
300 static ssize_t show_fan(struct device *dev, struct device_attribute *attr,
301  char *buf)
302 {
303  int nr = to_sensor_dev_attr(attr)->index;
304  struct asb100_data *data = asb100_update_device(dev);
305  return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan[nr],
306  DIV_FROM_REG(data->fan_div[nr])));
307 }
308 
309 static ssize_t show_fan_min(struct device *dev, struct device_attribute *attr,
310  char *buf)
311 {
312  int nr = to_sensor_dev_attr(attr)->index;
313  struct asb100_data *data = asb100_update_device(dev);
314  return sprintf(buf, "%d\n", FAN_FROM_REG(data->fan_min[nr],
315  DIV_FROM_REG(data->fan_div[nr])));
316 }
317 
318 static ssize_t show_fan_div(struct device *dev, struct device_attribute *attr,
319  char *buf)
320 {
321  int nr = to_sensor_dev_attr(attr)->index;
322  struct asb100_data *data = asb100_update_device(dev);
323  return sprintf(buf, "%d\n", DIV_FROM_REG(data->fan_div[nr]));
324 }
325 
326 static ssize_t set_fan_min(struct device *dev, struct device_attribute *attr,
327  const char *buf, size_t count)
328 {
329  int nr = to_sensor_dev_attr(attr)->index;
330  struct i2c_client *client = to_i2c_client(dev);
331  struct asb100_data *data = i2c_get_clientdata(client);
332  unsigned long val;
333  int err;
334 
335  err = kstrtoul(buf, 10, &val);
336  if (err)
337  return err;
338 
339  mutex_lock(&data->update_lock);
340  data->fan_min[nr] = FAN_TO_REG(val, DIV_FROM_REG(data->fan_div[nr]));
341  asb100_write_value(client, ASB100_REG_FAN_MIN(nr), data->fan_min[nr]);
342  mutex_unlock(&data->update_lock);
343  return count;
344 }
345 
346 /*
347  * Note: we save and restore the fan minimum here, because its value is
348  * determined in part by the fan divisor. This follows the principle of
349  * least surprise; the user doesn't expect the fan minimum to change just
350  * because the divisor changed.
351  */
352 static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr,
353  const char *buf, size_t count)
354 {
355  int nr = to_sensor_dev_attr(attr)->index;
356  struct i2c_client *client = to_i2c_client(dev);
357  struct asb100_data *data = i2c_get_clientdata(client);
358  unsigned long min;
359  int reg;
360  unsigned long val;
361  int err;
362 
363  err = kstrtoul(buf, 10, &val);
364  if (err)
365  return err;
366 
367  mutex_lock(&data->update_lock);
368 
369  min = FAN_FROM_REG(data->fan_min[nr],
370  DIV_FROM_REG(data->fan_div[nr]));
371  data->fan_div[nr] = DIV_TO_REG(val);
372 
373  switch (nr) {
374  case 0: /* fan 1 */
375  reg = asb100_read_value(client, ASB100_REG_VID_FANDIV);
376  reg = (reg & 0xcf) | (data->fan_div[0] << 4);
377  asb100_write_value(client, ASB100_REG_VID_FANDIV, reg);
378  break;
379 
380  case 1: /* fan 2 */
381  reg = asb100_read_value(client, ASB100_REG_VID_FANDIV);
382  reg = (reg & 0x3f) | (data->fan_div[1] << 6);
383  asb100_write_value(client, ASB100_REG_VID_FANDIV, reg);
384  break;
385 
386  case 2: /* fan 3 */
387  reg = asb100_read_value(client, ASB100_REG_PIN);
388  reg = (reg & 0x3f) | (data->fan_div[2] << 6);
389  asb100_write_value(client, ASB100_REG_PIN, reg);
390  break;
391  }
392 
393  data->fan_min[nr] =
394  FAN_TO_REG(min, DIV_FROM_REG(data->fan_div[nr]));
395  asb100_write_value(client, ASB100_REG_FAN_MIN(nr), data->fan_min[nr]);
396 
397  mutex_unlock(&data->update_lock);
398 
399  return count;
400 }
401 
402 #define sysfs_fan(offset) \
403 static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO, \
404  show_fan, NULL, offset - 1); \
405 static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
406  show_fan_min, set_fan_min, offset - 1); \
407 static SENSOR_DEVICE_ATTR(fan##offset##_div, S_IRUGO | S_IWUSR, \
408  show_fan_div, set_fan_div, offset - 1)
409 
410 sysfs_fan(1);
411 sysfs_fan(2);
412 sysfs_fan(3);
413 
414 /* 4 Temp. Sensors */
415 static int sprintf_temp_from_reg(u16 reg, char *buf, int nr)
416 {
417  int ret = 0;
418 
419  switch (nr) {
420  case 1: case 2:
421  ret = sprintf(buf, "%d\n", LM75_TEMP_FROM_REG(reg));
422  break;
423  case 0: case 3: default:
424  ret = sprintf(buf, "%d\n", TEMP_FROM_REG(reg));
425  break;
426  }
427  return ret;
428 }
429 
430 #define show_temp_reg(reg) \
431 static ssize_t show_##reg(struct device *dev, struct device_attribute *attr, \
432  char *buf) \
433 { \
434  int nr = to_sensor_dev_attr(attr)->index; \
435  struct asb100_data *data = asb100_update_device(dev); \
436  return sprintf_temp_from_reg(data->reg[nr], buf, nr); \
437 }
438 
442 
443 #define set_temp_reg(REG, reg) \
444 static ssize_t set_##reg(struct device *dev, struct device_attribute *attr, \
445  const char *buf, size_t count) \
446 { \
447  int nr = to_sensor_dev_attr(attr)->index; \
448  struct i2c_client *client = to_i2c_client(dev); \
449  struct asb100_data *data = i2c_get_clientdata(client); \
450  long val; \
451  int err = kstrtol(buf, 10, &val); \
452  if (err) \
453  return err; \
454  mutex_lock(&data->update_lock); \
455  switch (nr) { \
456  case 1: case 2: \
457  data->reg[nr] = LM75_TEMP_TO_REG(val); \
458  break; \
459  case 0: case 3: default: \
460  data->reg[nr] = TEMP_TO_REG(val); \
461  break; \
462  } \
463  asb100_write_value(client, ASB100_REG_TEMP_##REG(nr+1), \
464  data->reg[nr]); \
465  mutex_unlock(&data->update_lock); \
466  return count; \
467 }
468 
469 set_temp_reg(MAX, temp_max);
470 set_temp_reg(HYST, temp_hyst);
471 
472 #define sysfs_temp(num) \
473 static SENSOR_DEVICE_ATTR(temp##num##_input, S_IRUGO, \
474  show_temp, NULL, num - 1); \
475 static SENSOR_DEVICE_ATTR(temp##num##_max, S_IRUGO | S_IWUSR, \
476  show_temp_max, set_temp_max, num - 1); \
477 static SENSOR_DEVICE_ATTR(temp##num##_max_hyst, S_IRUGO | S_IWUSR, \
478  show_temp_hyst, set_temp_hyst, num - 1)
479 
480 sysfs_temp(1);
481 sysfs_temp(2);
482 sysfs_temp(3);
483 sysfs_temp(4);
484 
485 /* VID */
486 static ssize_t show_vid(struct device *dev, struct device_attribute *attr,
487  char *buf)
488 {
489  struct asb100_data *data = asb100_update_device(dev);
490  return sprintf(buf, "%d\n", vid_from_reg(data->vid, data->vrm));
491 }
492 
493 static DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid, NULL);
494 
495 /* VRM */
496 static ssize_t show_vrm(struct device *dev, struct device_attribute *attr,
497  char *buf)
498 {
499  struct asb100_data *data = dev_get_drvdata(dev);
500  return sprintf(buf, "%d\n", data->vrm);
501 }
502 
503 static ssize_t set_vrm(struct device *dev, struct device_attribute *attr,
504  const char *buf, size_t count)
505 {
506  struct asb100_data *data = dev_get_drvdata(dev);
507  unsigned long val;
508  int err;
509 
510  err = kstrtoul(buf, 10, &val);
511  if (err)
512  return err;
513  data->vrm = val;
514  return count;
515 }
516 
517 /* Alarms */
518 static DEVICE_ATTR(vrm, S_IRUGO | S_IWUSR, show_vrm, set_vrm);
519 
520 static ssize_t show_alarms(struct device *dev, struct device_attribute *attr,
521  char *buf)
522 {
523  struct asb100_data *data = asb100_update_device(dev);
524  return sprintf(buf, "%u\n", data->alarms);
525 }
526 
527 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
528 
529 static ssize_t show_alarm(struct device *dev, struct device_attribute *attr,
530  char *buf)
531 {
532  int bitnr = to_sensor_dev_attr(attr)->index;
533  struct asb100_data *data = asb100_update_device(dev);
534  return sprintf(buf, "%u\n", (data->alarms >> bitnr) & 1);
535 }
536 static SENSOR_DEVICE_ATTR(in0_alarm, S_IRUGO, show_alarm, NULL, 0);
537 static SENSOR_DEVICE_ATTR(in1_alarm, S_IRUGO, show_alarm, NULL, 1);
538 static SENSOR_DEVICE_ATTR(in2_alarm, S_IRUGO, show_alarm, NULL, 2);
539 static SENSOR_DEVICE_ATTR(in3_alarm, S_IRUGO, show_alarm, NULL, 3);
540 static SENSOR_DEVICE_ATTR(in4_alarm, S_IRUGO, show_alarm, NULL, 8);
541 static SENSOR_DEVICE_ATTR(fan1_alarm, S_IRUGO, show_alarm, NULL, 6);
542 static SENSOR_DEVICE_ATTR(fan2_alarm, S_IRUGO, show_alarm, NULL, 7);
543 static SENSOR_DEVICE_ATTR(fan3_alarm, S_IRUGO, show_alarm, NULL, 11);
544 static SENSOR_DEVICE_ATTR(temp1_alarm, S_IRUGO, show_alarm, NULL, 4);
545 static SENSOR_DEVICE_ATTR(temp2_alarm, S_IRUGO, show_alarm, NULL, 5);
546 static SENSOR_DEVICE_ATTR(temp3_alarm, S_IRUGO, show_alarm, NULL, 13);
547 
548 /* 1 PWM */
549 static ssize_t show_pwm1(struct device *dev, struct device_attribute *attr,
550  char *buf)
551 {
552  struct asb100_data *data = asb100_update_device(dev);
553  return sprintf(buf, "%d\n", ASB100_PWM_FROM_REG(data->pwm & 0x0f));
554 }
555 
556 static ssize_t set_pwm1(struct device *dev, struct device_attribute *attr,
557  const char *buf, size_t count)
558 {
559  struct i2c_client *client = to_i2c_client(dev);
560  struct asb100_data *data = i2c_get_clientdata(client);
561  unsigned long val;
562  int err;
563 
564  err = kstrtoul(buf, 10, &val);
565  if (err)
566  return err;
567 
568  mutex_lock(&data->update_lock);
569  data->pwm &= 0x80; /* keep the enable bit */
570  data->pwm |= (0x0f & ASB100_PWM_TO_REG(val));
571  asb100_write_value(client, ASB100_REG_PWM1, data->pwm);
572  mutex_unlock(&data->update_lock);
573  return count;
574 }
575 
576 static ssize_t show_pwm_enable1(struct device *dev,
577  struct device_attribute *attr, char *buf)
578 {
579  struct asb100_data *data = asb100_update_device(dev);
580  return sprintf(buf, "%d\n", (data->pwm & 0x80) ? 1 : 0);
581 }
582 
583 static ssize_t set_pwm_enable1(struct device *dev,
584  struct device_attribute *attr, const char *buf, size_t count)
585 {
586  struct i2c_client *client = to_i2c_client(dev);
587  struct asb100_data *data = i2c_get_clientdata(client);
588  unsigned long val;
589  int err;
590 
591  err = kstrtoul(buf, 10, &val);
592  if (err)
593  return err;
594 
595  mutex_lock(&data->update_lock);
596  data->pwm &= 0x0f; /* keep the duty cycle bits */
597  data->pwm |= (val ? 0x80 : 0x00);
598  asb100_write_value(client, ASB100_REG_PWM1, data->pwm);
599  mutex_unlock(&data->update_lock);
600  return count;
601 }
602 
603 static DEVICE_ATTR(pwm1, S_IRUGO | S_IWUSR, show_pwm1, set_pwm1);
604 static DEVICE_ATTR(pwm1_enable, S_IRUGO | S_IWUSR,
605  show_pwm_enable1, set_pwm_enable1);
606 
607 static struct attribute *asb100_attributes[] = {
608  &sensor_dev_attr_in0_input.dev_attr.attr,
609  &sensor_dev_attr_in0_min.dev_attr.attr,
610  &sensor_dev_attr_in0_max.dev_attr.attr,
611  &sensor_dev_attr_in1_input.dev_attr.attr,
612  &sensor_dev_attr_in1_min.dev_attr.attr,
613  &sensor_dev_attr_in1_max.dev_attr.attr,
614  &sensor_dev_attr_in2_input.dev_attr.attr,
615  &sensor_dev_attr_in2_min.dev_attr.attr,
616  &sensor_dev_attr_in2_max.dev_attr.attr,
617  &sensor_dev_attr_in3_input.dev_attr.attr,
618  &sensor_dev_attr_in3_min.dev_attr.attr,
619  &sensor_dev_attr_in3_max.dev_attr.attr,
620  &sensor_dev_attr_in4_input.dev_attr.attr,
621  &sensor_dev_attr_in4_min.dev_attr.attr,
622  &sensor_dev_attr_in4_max.dev_attr.attr,
623  &sensor_dev_attr_in5_input.dev_attr.attr,
624  &sensor_dev_attr_in5_min.dev_attr.attr,
625  &sensor_dev_attr_in5_max.dev_attr.attr,
626  &sensor_dev_attr_in6_input.dev_attr.attr,
627  &sensor_dev_attr_in6_min.dev_attr.attr,
628  &sensor_dev_attr_in6_max.dev_attr.attr,
629 
630  &sensor_dev_attr_fan1_input.dev_attr.attr,
631  &sensor_dev_attr_fan1_min.dev_attr.attr,
632  &sensor_dev_attr_fan1_div.dev_attr.attr,
633  &sensor_dev_attr_fan2_input.dev_attr.attr,
634  &sensor_dev_attr_fan2_min.dev_attr.attr,
635  &sensor_dev_attr_fan2_div.dev_attr.attr,
636  &sensor_dev_attr_fan3_input.dev_attr.attr,
637  &sensor_dev_attr_fan3_min.dev_attr.attr,
638  &sensor_dev_attr_fan3_div.dev_attr.attr,
639 
640  &sensor_dev_attr_temp1_input.dev_attr.attr,
641  &sensor_dev_attr_temp1_max.dev_attr.attr,
642  &sensor_dev_attr_temp1_max_hyst.dev_attr.attr,
643  &sensor_dev_attr_temp2_input.dev_attr.attr,
644  &sensor_dev_attr_temp2_max.dev_attr.attr,
645  &sensor_dev_attr_temp2_max_hyst.dev_attr.attr,
646  &sensor_dev_attr_temp3_input.dev_attr.attr,
647  &sensor_dev_attr_temp3_max.dev_attr.attr,
648  &sensor_dev_attr_temp3_max_hyst.dev_attr.attr,
649  &sensor_dev_attr_temp4_input.dev_attr.attr,
650  &sensor_dev_attr_temp4_max.dev_attr.attr,
651  &sensor_dev_attr_temp4_max_hyst.dev_attr.attr,
652 
653  &sensor_dev_attr_in0_alarm.dev_attr.attr,
654  &sensor_dev_attr_in1_alarm.dev_attr.attr,
655  &sensor_dev_attr_in2_alarm.dev_attr.attr,
656  &sensor_dev_attr_in3_alarm.dev_attr.attr,
657  &sensor_dev_attr_in4_alarm.dev_attr.attr,
658  &sensor_dev_attr_fan1_alarm.dev_attr.attr,
659  &sensor_dev_attr_fan2_alarm.dev_attr.attr,
660  &sensor_dev_attr_fan3_alarm.dev_attr.attr,
661  &sensor_dev_attr_temp1_alarm.dev_attr.attr,
662  &sensor_dev_attr_temp2_alarm.dev_attr.attr,
663  &sensor_dev_attr_temp3_alarm.dev_attr.attr,
664 
665  &dev_attr_cpu0_vid.attr,
666  &dev_attr_vrm.attr,
667  &dev_attr_alarms.attr,
668  &dev_attr_pwm1.attr,
669  &dev_attr_pwm1_enable.attr,
670 
671  NULL
672 };
673 
674 static const struct attribute_group asb100_group = {
675  .attrs = asb100_attributes,
676 };
677 
678 static int asb100_detect_subclients(struct i2c_client *client)
679 {
680  int i, id, err;
681  int address = client->addr;
682  unsigned short sc_addr[2];
683  struct asb100_data *data = i2c_get_clientdata(client);
684  struct i2c_adapter *adapter = client->adapter;
685 
686  id = i2c_adapter_id(adapter);
687 
688  if (force_subclients[0] == id && force_subclients[1] == address) {
689  for (i = 2; i <= 3; i++) {
690  if (force_subclients[i] < 0x48 ||
691  force_subclients[i] > 0x4f) {
692  dev_err(&client->dev, "invalid subclient "
693  "address %d; must be 0x48-0x4f\n",
694  force_subclients[i]);
695  err = -ENODEV;
696  goto ERROR_SC_2;
697  }
698  }
699  asb100_write_value(client, ASB100_REG_I2C_SUBADDR,
700  (force_subclients[2] & 0x07) |
701  ((force_subclients[3] & 0x07) << 4));
702  sc_addr[0] = force_subclients[2];
703  sc_addr[1] = force_subclients[3];
704  } else {
705  int val = asb100_read_value(client, ASB100_REG_I2C_SUBADDR);
706  sc_addr[0] = 0x48 + (val & 0x07);
707  sc_addr[1] = 0x48 + ((val >> 4) & 0x07);
708  }
709 
710  if (sc_addr[0] == sc_addr[1]) {
711  dev_err(&client->dev, "duplicate addresses 0x%x "
712  "for subclients\n", sc_addr[0]);
713  err = -ENODEV;
714  goto ERROR_SC_2;
715  }
716 
717  data->lm75[0] = i2c_new_dummy(adapter, sc_addr[0]);
718  if (!data->lm75[0]) {
719  dev_err(&client->dev, "subclient %d registration "
720  "at address 0x%x failed.\n", 1, sc_addr[0]);
721  err = -ENOMEM;
722  goto ERROR_SC_2;
723  }
724 
725  data->lm75[1] = i2c_new_dummy(adapter, sc_addr[1]);
726  if (!data->lm75[1]) {
727  dev_err(&client->dev, "subclient %d registration "
728  "at address 0x%x failed.\n", 2, sc_addr[1]);
729  err = -ENOMEM;
730  goto ERROR_SC_3;
731  }
732 
733  return 0;
734 
735 /* Undo inits in case of errors */
736 ERROR_SC_3:
737  i2c_unregister_device(data->lm75[0]);
738 ERROR_SC_2:
739  return err;
740 }
741 
742 /* Return 0 if detection is successful, -ENODEV otherwise */
743 static int asb100_detect(struct i2c_client *client,
744  struct i2c_board_info *info)
745 {
746  struct i2c_adapter *adapter = client->adapter;
747  int val1, val2;
748 
749  if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
750  pr_debug("detect failed, smbus byte data not supported!\n");
751  return -ENODEV;
752  }
753 
756 
757  /* If we're in bank 0 */
758  if ((!(val1 & 0x07)) &&
759  /* Check for ASB100 ID (low byte) */
760  (((!(val1 & 0x80)) && (val2 != 0x94)) ||
761  /* Check for ASB100 ID (high byte ) */
762  ((val1 & 0x80) && (val2 != 0x06)))) {
763  pr_debug("detect failed, bad chip id 0x%02x!\n", val2);
764  return -ENODEV;
765  }
766 
767  /* Put it now into bank 0 and Vendor ID High Byte */
769  (i2c_smbus_read_byte_data(client, ASB100_REG_BANK) & 0x78)
770  | 0x80);
771 
772  /* Determine the chip type. */
775 
776  if (val1 != 0x31 || val2 != 0x06)
777  return -ENODEV;
778 
779  strlcpy(info->type, "asb100", I2C_NAME_SIZE);
780 
781  return 0;
782 }
783 
784 static int asb100_probe(struct i2c_client *client,
785  const struct i2c_device_id *id)
786 {
787  int err;
788  struct asb100_data *data;
789 
790  data = devm_kzalloc(&client->dev, sizeof(struct asb100_data),
791  GFP_KERNEL);
792  if (!data)
793  return -ENOMEM;
794 
795  i2c_set_clientdata(client, data);
796  mutex_init(&data->lock);
797  mutex_init(&data->update_lock);
798 
799  /* Attach secondary lm75 clients */
800  err = asb100_detect_subclients(client);
801  if (err)
802  return err;
803 
804  /* Initialize the chip */
805  asb100_init_client(client);
806 
807  /* A few vars need to be filled upon startup */
808  data->fan_min[0] = asb100_read_value(client, ASB100_REG_FAN_MIN(0));
809  data->fan_min[1] = asb100_read_value(client, ASB100_REG_FAN_MIN(1));
810  data->fan_min[2] = asb100_read_value(client, ASB100_REG_FAN_MIN(2));
811 
812  /* Register sysfs hooks */
813  err = sysfs_create_group(&client->dev.kobj, &asb100_group);
814  if (err)
815  goto ERROR3;
816 
817  data->hwmon_dev = hwmon_device_register(&client->dev);
818  if (IS_ERR(data->hwmon_dev)) {
819  err = PTR_ERR(data->hwmon_dev);
820  goto ERROR4;
821  }
822 
823  return 0;
824 
825 ERROR4:
826  sysfs_remove_group(&client->dev.kobj, &asb100_group);
827 ERROR3:
828  i2c_unregister_device(data->lm75[1]);
829  i2c_unregister_device(data->lm75[0]);
830  return err;
831 }
832 
833 static int asb100_remove(struct i2c_client *client)
834 {
835  struct asb100_data *data = i2c_get_clientdata(client);
836 
838  sysfs_remove_group(&client->dev.kobj, &asb100_group);
839 
840  i2c_unregister_device(data->lm75[1]);
841  i2c_unregister_device(data->lm75[0]);
842 
843  return 0;
844 }
845 
846 /*
847  * The SMBus locks itself, usually, but nothing may access the chip between
848  * bank switches.
849  */
850 static int asb100_read_value(struct i2c_client *client, u16 reg)
851 {
852  struct asb100_data *data = i2c_get_clientdata(client);
853  struct i2c_client *cl;
854  int res, bank;
855 
856  mutex_lock(&data->lock);
857 
858  bank = (reg >> 8) & 0x0f;
859  if (bank > 2)
860  /* switch banks */
862 
863  if (bank == 0 || bank > 2) {
864  res = i2c_smbus_read_byte_data(client, reg & 0xff);
865  } else {
866  /* switch to subclient */
867  cl = data->lm75[bank - 1];
868 
869  /* convert from ISA to LM75 I2C addresses */
870  switch (reg & 0xff) {
871  case 0x50: /* TEMP */
872  res = i2c_smbus_read_word_swapped(cl, 0);
873  break;
874  case 0x52: /* CONFIG */
875  res = i2c_smbus_read_byte_data(cl, 1);
876  break;
877  case 0x53: /* HYST */
878  res = i2c_smbus_read_word_swapped(cl, 2);
879  break;
880  case 0x55: /* MAX */
881  default:
882  res = i2c_smbus_read_word_swapped(cl, 3);
883  break;
884  }
885  }
886 
887  if (bank > 2)
889 
890  mutex_unlock(&data->lock);
891 
892  return res;
893 }
894 
895 static void asb100_write_value(struct i2c_client *client, u16 reg, u16 value)
896 {
897  struct asb100_data *data = i2c_get_clientdata(client);
898  struct i2c_client *cl;
899  int bank;
900 
901  mutex_lock(&data->lock);
902 
903  bank = (reg >> 8) & 0x0f;
904  if (bank > 2)
905  /* switch banks */
907 
908  if (bank == 0 || bank > 2) {
909  i2c_smbus_write_byte_data(client, reg & 0xff, value & 0xff);
910  } else {
911  /* switch to subclient */
912  cl = data->lm75[bank - 1];
913 
914  /* convert from ISA to LM75 I2C addresses */
915  switch (reg & 0xff) {
916  case 0x52: /* CONFIG */
917  i2c_smbus_write_byte_data(cl, 1, value & 0xff);
918  break;
919  case 0x53: /* HYST */
920  i2c_smbus_write_word_swapped(cl, 2, value);
921  break;
922  case 0x55: /* MAX */
923  i2c_smbus_write_word_swapped(cl, 3, value);
924  break;
925  }
926  }
927 
928  if (bank > 2)
930 
931  mutex_unlock(&data->lock);
932 }
933 
934 static void asb100_init_client(struct i2c_client *client)
935 {
936  struct asb100_data *data = i2c_get_clientdata(client);
937 
938  data->vrm = vid_which_vrm();
939 
940  /* Start monitoring */
941  asb100_write_value(client, ASB100_REG_CONFIG,
942  (asb100_read_value(client, ASB100_REG_CONFIG) & 0xf7) | 0x01);
943 }
944 
945 static struct asb100_data *asb100_update_device(struct device *dev)
946 {
947  struct i2c_client *client = to_i2c_client(dev);
948  struct asb100_data *data = i2c_get_clientdata(client);
949  int i;
950 
951  mutex_lock(&data->update_lock);
952 
953  if (time_after(jiffies, data->last_updated + HZ + HZ / 2)
954  || !data->valid) {
955 
956  dev_dbg(&client->dev, "starting device update...\n");
957 
958  /* 7 voltage inputs */
959  for (i = 0; i < 7; i++) {
960  data->in[i] = asb100_read_value(client,
961  ASB100_REG_IN(i));
962  data->in_min[i] = asb100_read_value(client,
963  ASB100_REG_IN_MIN(i));
964  data->in_max[i] = asb100_read_value(client,
965  ASB100_REG_IN_MAX(i));
966  }
967 
968  /* 3 fan inputs */
969  for (i = 0; i < 3; i++) {
970  data->fan[i] = asb100_read_value(client,
971  ASB100_REG_FAN(i));
972  data->fan_min[i] = asb100_read_value(client,
973  ASB100_REG_FAN_MIN(i));
974  }
975 
976  /* 4 temperature inputs */
977  for (i = 1; i <= 4; i++) {
978  data->temp[i-1] = asb100_read_value(client,
979  ASB100_REG_TEMP(i));
980  data->temp_max[i-1] = asb100_read_value(client,
982  data->temp_hyst[i-1] = asb100_read_value(client,
984  }
985 
986  /* VID and fan divisors */
987  i = asb100_read_value(client, ASB100_REG_VID_FANDIV);
988  data->vid = i & 0x0f;
989  data->vid |= (asb100_read_value(client,
990  ASB100_REG_CHIPID) & 0x01) << 4;
991  data->fan_div[0] = (i >> 4) & 0x03;
992  data->fan_div[1] = (i >> 6) & 0x03;
993  data->fan_div[2] = (asb100_read_value(client,
994  ASB100_REG_PIN) >> 6) & 0x03;
995 
996  /* PWM */
997  data->pwm = asb100_read_value(client, ASB100_REG_PWM1);
998 
999  /* alarms */
1000  data->alarms = asb100_read_value(client, ASB100_REG_ALARM1) +
1001  (asb100_read_value(client, ASB100_REG_ALARM2) << 8);
1002 
1003  data->last_updated = jiffies;
1004  data->valid = 1;
1005 
1006  dev_dbg(&client->dev, "... device update complete\n");
1007  }
1008 
1009  mutex_unlock(&data->update_lock);
1010 
1011  return data;
1012 }
1013 
1014 module_i2c_driver(asb100_driver);
1015 
1016 MODULE_AUTHOR("Mark M. Hoffman <[email protected]>");
1017 MODULE_DESCRIPTION("ASB100 Bach driver");
1018 MODULE_LICENSE("GPL");