?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Chinese: add translation of oops-tracing.txt
[linux-2.6/linux-2.6-openrd.git] / drivers / hwmon / lm93.c
blobea61946a4bf76ede2aa2cb4d7af0c42fb6c73220
1 /*
2 lm93.c - Part of lm_sensors, Linux kernel modules for hardware monitoring
3
4 Author/Maintainer: Mark M. Hoffman <mhoffman@lightlink.com>
5 Copyright (c) 2004 Utilitek Systems, Inc.
6
7 derived in part from lm78.c:
8 Copyright (c) 1998, 1999 Frodo Looijaard <frodol@dds.nl>
9
10 derived in part from lm85.c:
11 Copyright (c) 2002, 2003 Philip Pokorny <ppokorny@penguincomputing.com>
12 Copyright (c) 2003 Margit Schubert-While <margitsw@t-online.de>
13
14 derived in part from w83l785ts.c:
15 Copyright (c) 2003-2004 Jean Delvare <khali@linux-fr.org>
16
17 Ported to Linux 2.6 by Eric J. Bowersox <ericb@aspsys.com>
18 Copyright (c) 2005 Aspen Systems, Inc.
19
20 Adapted to 2.6.20 by Carsten Emde <cbe@osadl.org>
21 Copyright (c) 2006 Carsten Emde, Open Source Automation Development Lab
22
23 Modified for mainline integration by Hans J. Koch <hjk@linutronix.de>
24 Copyright (c) 2007 Hans J. Koch, Linutronix GmbH
25
26 This program is free software; you can redistribute it and/or modify
27 it under the terms of the GNU General Public License as published by
28 the Free Software Foundation; either version 2 of the License, or
29 (at your option) any later version.
30
31 This program is distributed in the hope that it will be useful,
32 but WITHOUT ANY WARRANTY; without even the implied warranty of
33 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
34 GNU General Public License for more details.
35
36 You should have received a copy of the GNU General Public License
37 along with this program; if not, write to the Free Software
38 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
39 */
40
41 #include <linux/module.h>
42 #include <linux/init.h>
43 #include <linux/slab.h>
44 #include <linux/i2c.h>
45 #include <linux/hwmon.h>
46 #include <linux/hwmon-sysfs.h>
47 #include <linux/hwmon-vid.h>
48 #include <linux/err.h>
49 #include <linux/delay.h>
50
51 /* LM93 REGISTER ADDRESSES */
52
53 /* miscellaneous */
54 #define LM93_REG_MFR_ID 0x3e
55 #define LM93_REG_VER 0x3f
56 #define LM93_REG_STATUS_CONTROL 0xe2
57 #define LM93_REG_CONFIG 0xe3
58 #define LM93_REG_SLEEP_CONTROL 0xe4
59
60 /* alarm values start here */
61 #define LM93_REG_HOST_ERROR_1 0x48
62
63 /* voltage inputs: in1-in16 (nr => 0-15) */
64 #define LM93_REG_IN(nr) (0x56 + (nr))
65 #define LM93_REG_IN_MIN(nr) (0x90 + (nr) * 2)
66 #define LM93_REG_IN_MAX(nr) (0x91 + (nr) * 2)
67
68 /* temperature inputs: temp1-temp4 (nr => 0-3) */
69 #define LM93_REG_TEMP(nr) (0x50 + (nr))
70 #define LM93_REG_TEMP_MIN(nr) (0x78 + (nr) * 2)
71 #define LM93_REG_TEMP_MAX(nr) (0x79 + (nr) * 2)
72
73 /* temp[1-4]_auto_boost (nr => 0-3) */
74 #define LM93_REG_BOOST(nr) (0x80 + (nr))
75
76 /* #PROCHOT inputs: prochot1-prochot2 (nr => 0-1) */
77 #define LM93_REG_PROCHOT_CUR(nr) (0x67 + (nr) * 2)
78 #define LM93_REG_PROCHOT_AVG(nr) (0x68 + (nr) * 2)
79 #define LM93_REG_PROCHOT_MAX(nr) (0xb0 + (nr))
80
81 /* fan tach inputs: fan1-fan4 (nr => 0-3) */
82 #define LM93_REG_FAN(nr) (0x6e + (nr) * 2)
83 #define LM93_REG_FAN_MIN(nr) (0xb4 + (nr) * 2)
84
85 /* pwm outputs: pwm1-pwm2 (nr => 0-1, reg => 0-3) */
86 #define LM93_REG_PWM_CTL(nr,reg) (0xc8 + (reg) + (nr) * 4)
87 #define LM93_PWM_CTL1 0x0
88 #define LM93_PWM_CTL2 0x1
89 #define LM93_PWM_CTL3 0x2
90 #define LM93_PWM_CTL4 0x3
91
92 /* GPIO input state */
93 #define LM93_REG_GPI 0x6b
94
95 /* vid inputs: vid1-vid2 (nr => 0-1) */
96 #define LM93_REG_VID(nr) (0x6c + (nr))
97
98 /* vccp1 & vccp2: VID relative inputs (nr => 0-1) */
99 #define LM93_REG_VCCP_LIMIT_OFF(nr) (0xb2 + (nr))
100
101 /* temp[1-4]_auto_boost_hyst */
102 #define LM93_REG_BOOST_HYST_12 0xc0
103 #define LM93_REG_BOOST_HYST_34 0xc1
104 #define LM93_REG_BOOST_HYST(nr) (0xc0 + (nr)/2)
105
106 /* temp[1-4]_auto_pwm_[min|hyst] */
107 #define LM93_REG_PWM_MIN_HYST_12 0xc3
108 #define LM93_REG_PWM_MIN_HYST_34 0xc4
109 #define LM93_REG_PWM_MIN_HYST(nr) (0xc3 + (nr)/2)
110
111 /* prochot_override & prochot_interval */
112 #define LM93_REG_PROCHOT_OVERRIDE 0xc6
113 #define LM93_REG_PROCHOT_INTERVAL 0xc7
114
115 /* temp[1-4]_auto_base (nr => 0-3) */
116 #define LM93_REG_TEMP_BASE(nr) (0xd0 + (nr))
117
118 /* temp[1-4]_auto_offsets (step => 0-11) */
119 #define LM93_REG_TEMP_OFFSET(step) (0xd4 + (step))
120
121 /* #PROCHOT & #VRDHOT PWM ramp control */
122 #define LM93_REG_PWM_RAMP_CTL 0xbf
123
124 /* miscellaneous */
125 #define LM93_REG_SFC1 0xbc
126 #define LM93_REG_SFC2 0xbd
127 #define LM93_REG_GPI_VID_CTL 0xbe
128 #define LM93_REG_SF_TACH_TO_PWM 0xe0
129
130 /* error masks */
131 #define LM93_REG_GPI_ERR_MASK 0xec
132 #define LM93_REG_MISC_ERR_MASK 0xed
133
134 /* LM93 REGISTER VALUES */
135 #define LM93_MFR_ID 0x73
136 #define LM93_MFR_ID_PROTOTYPE 0x72
137
138 /* SMBus capabilities */
139 #define LM93_SMBUS_FUNC_FULL (I2C_FUNC_SMBUS_BYTE_DATA | \
140 I2C_FUNC_SMBUS_WORD_DATA | I2C_FUNC_SMBUS_BLOCK_DATA)
141 #define LM93_SMBUS_FUNC_MIN (I2C_FUNC_SMBUS_BYTE_DATA | \
142 I2C_FUNC_SMBUS_WORD_DATA)
143
144 /* Addresses to scan */
145 static unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, I2C_CLIENT_END };
146
147 /* Insmod parameters */
148 I2C_CLIENT_INSMOD_1(lm93);
149
150 static int disable_block;
151 module_param(disable_block, bool, 0);
152 MODULE_PARM_DESC(disable_block,
153 "Set to non-zero to disable SMBus block data transactions.");
154
155 static int init;
156 module_param(init, bool, 0);
157 MODULE_PARM_DESC(init, "Set to non-zero to force chip initialization.");
158
159 static int vccp_limit_type[2] = {0,0};
160 module_param_array(vccp_limit_type, int, NULL, 0);
161 MODULE_PARM_DESC(vccp_limit_type, "Configures in7 and in8 limit modes.");
162
163 static int vid_agtl;
164 module_param(vid_agtl, int, 0);
165 MODULE_PARM_DESC(vid_agtl, "Configures VID pin input thresholds.");
166
167 /* Driver data */
168 static struct i2c_driver lm93_driver;
169
170 /* LM93 BLOCK READ COMMANDS */
171 static const struct { u8 cmd; u8 len; } lm93_block_read_cmds[12] = {
172 { 0xf2, 8 },
173 { 0xf3, 8 },
174 { 0xf4, 6 },
175 { 0xf5, 16 },
176 { 0xf6, 4 },
177 { 0xf7, 8 },
178 { 0xf8, 12 },
179 { 0xf9, 32 },
180 { 0xfa, 8 },
181 { 0xfb, 8 },
182 { 0xfc, 16 },
183 { 0xfd, 9 },
184 };
185
186 /* ALARMS: SYSCTL format described further below
187 REG: 64 bits in 8 registers, as immediately below */
188 struct block1_t {
189 u8 host_status_1;
190 u8 host_status_2;
191 u8 host_status_3;
192 u8 host_status_4;
193 u8 p1_prochot_status;
194 u8 p2_prochot_status;
195 u8 gpi_status;
196 u8 fan_status;
197 };
198
199 /*
200 * Client-specific data
201 */
202 struct lm93_data {
203 struct i2c_client client;
204 struct device *hwmon_dev;
205
206 struct mutex update_lock;
207 unsigned long last_updated; /* In jiffies */
208
209 /* client update function */
210 void (*update)(struct lm93_data *, struct i2c_client *);
211
212 char valid; /* !=0 if following fields are valid */
213
214 /* register values, arranged by block read groups */
215 struct block1_t block1;
216
217 /* temp1 - temp4: unfiltered readings
218 temp1 - temp2: filtered readings */
219 u8 block2[6];
220
221 /* vin1 - vin16: readings */
222 u8 block3[16];
223
224 /* prochot1 - prochot2: readings */
225 struct {
226 u8 cur;
227 u8 avg;
228 } block4[2];
229
230 /* fan counts 1-4 => 14-bits, LE, *left* justified */
231 u16 block5[4];
232
233 /* block6 has a lot of data we don't need */
234 struct {
235 u8 min;
236 u8 max;
237 } temp_lim[4];
238
239 /* vin1 - vin16: low and high limits */
240 struct {
241 u8 min;
242 u8 max;
243 } block7[16];
244
245 /* fan count limits 1-4 => same format as block5 */
246 u16 block8[4];
247
248 /* pwm control registers (2 pwms, 4 regs) */
249 u8 block9[2][4];
250
251 /* auto/pwm base temp and offset temp registers */
252 struct {
253 u8 base[4];
254 u8 offset[12];
255 } block10;
256
257 /* master config register */
258 u8 config;
259
260 /* VID1 & VID2 => register format, 6-bits, right justified */
261 u8 vid[2];
262
263 /* prochot1 - prochot2: limits */
264 u8 prochot_max[2];
265
266 /* vccp1 & vccp2 (in7 & in8): VID relative limits (register format) */
267 u8 vccp_limits[2];
268
269 /* GPIO input state (register format, i.e. inverted) */
270 u8 gpi;
271
272 /* #PROCHOT override (register format) */
273 u8 prochot_override;
274
275 /* #PROCHOT intervals (register format) */
276 u8 prochot_interval;
277
278 /* Fan Boost Temperatures (register format) */
279 u8 boost[4];
280
281 /* Fan Boost Hysteresis (register format) */
282 u8 boost_hyst[2];
283
284 /* Temperature Zone Min. PWM & Hysteresis (register format) */
285 u8 auto_pwm_min_hyst[2];
286
287 /* #PROCHOT & #VRDHOT PWM Ramp Control */
288 u8 pwm_ramp_ctl;
289
290 /* miscellaneous setup regs */
291 u8 sfc1;
292 u8 sfc2;
293 u8 sf_tach_to_pwm;
294
295 /* The two PWM CTL2 registers can read something other than what was
296 last written for the OVR_DC field (duty cycle override). So, we
297 save the user-commanded value here. */
298 u8 pwm_override[2];
299 };
300
301 /* VID: mV
302 REG: 6-bits, right justified, *always* using Intel VRM/VRD 10 */
303 static int LM93_VID_FROM_REG(u8 reg)
304 {
305 return vid_from_reg((reg & 0x3f), 100);
306 }
307
308 /* min, max, and nominal register values, per channel (u8) */
309 static const u8 lm93_vin_reg_min[16] = {
310 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
311 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xae,
312 };
313 static const u8 lm93_vin_reg_max[16] = {
314 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
315 0xff, 0xfa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd1,
316 };
317 /* Values from the datasheet. They're here for documentation only.
318 static const u8 lm93_vin_reg_nom[16] = {
319 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0,
320 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0x40, 0xc0,
321 };
322 */
323
324 /* min, max, and nominal voltage readings, per channel (mV)*/
325 static const unsigned long lm93_vin_val_min[16] = {
326 0, 0, 0, 0, 0, 0, 0, 0,
327 0, 0, 0, 0, 0, 0, 0, 3000,
328 };
329
330 static const unsigned long lm93_vin_val_max[16] = {
331 1236, 1236, 1236, 1600, 2000, 2000, 1600, 1600,
332 4400, 6500, 3333, 2625, 1312, 1312, 1236, 3600,
333 };
334 /* Values from the datasheet. They're here for documentation only.
335 static const unsigned long lm93_vin_val_nom[16] = {
336 927, 927, 927, 1200, 1500, 1500, 1200, 1200,
337 3300, 5000, 2500, 1969, 984, 984, 309, 3300,
338 };
339 */
340
341 static unsigned LM93_IN_FROM_REG(int nr, u8 reg)
342 {
343 const long uV_max = lm93_vin_val_max[nr] * 1000;
344 const long uV_min = lm93_vin_val_min[nr] * 1000;
345
346 const long slope = (uV_max - uV_min) /
347 (lm93_vin_reg_max[nr] - lm93_vin_reg_min[nr]);
348 const long intercept = uV_min - slope * lm93_vin_reg_min[nr];
349
350 return (slope * reg + intercept + 500) / 1000;
351 }
352
353 /* IN: mV, limits determined by channel nr
354 REG: scaling determined by channel nr */
355 static u8 LM93_IN_TO_REG(int nr, unsigned val)
356 {
357 /* range limit */
358 const long mV = SENSORS_LIMIT(val,
359 lm93_vin_val_min[nr], lm93_vin_val_max[nr]);
360
361 /* try not to lose too much precision here */
362 const long uV = mV * 1000;
363 const long uV_max = lm93_vin_val_max[nr] * 1000;
364 const long uV_min = lm93_vin_val_min[nr] * 1000;
365
366 /* convert */
367 const long slope = (uV_max - uV_min) /
368 (lm93_vin_reg_max[nr] - lm93_vin_reg_min[nr]);
369 const long intercept = uV_min - slope * lm93_vin_reg_min[nr];
370
371 u8 result = ((uV - intercept + (slope/2)) / slope);
372 result = SENSORS_LIMIT(result,
373 lm93_vin_reg_min[nr], lm93_vin_reg_max[nr]);
374 return result;
375 }
376
377 /* vid in mV, upper == 0 indicates low limit, otherwise upper limit */
378 static unsigned LM93_IN_REL_FROM_REG(u8 reg, int upper, int vid)
379 {
380 const long uV_offset = upper ? (((reg >> 4 & 0x0f) + 1) * 12500) :
381 (((reg >> 0 & 0x0f) + 1) * -25000);
382 const long uV_vid = vid * 1000;
383 return (uV_vid + uV_offset + 5000) / 10000;
384 }
385
386 #define LM93_IN_MIN_FROM_REG(reg,vid) LM93_IN_REL_FROM_REG(reg,0,vid)
387 #define LM93_IN_MAX_FROM_REG(reg,vid) LM93_IN_REL_FROM_REG(reg,1,vid)
388
389 /* vid in mV , upper == 0 indicates low limit, otherwise upper limit
390 upper also determines which nibble of the register is returned
391 (the other nibble will be 0x0) */
392 static u8 LM93_IN_REL_TO_REG(unsigned val, int upper, int vid)
393 {
394 long uV_offset = vid * 1000 - val * 10000;
395 if (upper) {
396 uV_offset = SENSORS_LIMIT(uV_offset, 12500, 200000);
397 return (u8)((uV_offset / 12500 - 1) << 4);
398 } else {
399 uV_offset = SENSORS_LIMIT(uV_offset, -400000, -25000);
400 return (u8)((uV_offset / -25000 - 1) << 0);
401 }
402 }
403
404 /* TEMP: 1/1000 degrees C (-128C to +127C)
405 REG: 1C/bit, two's complement */
406 static int LM93_TEMP_FROM_REG(u8 reg)
407 {
408 return (s8)reg * 1000;
409 }
410
411 #define LM93_TEMP_MIN (-128000)
412 #define LM93_TEMP_MAX ( 127000)
413
414 /* TEMP: 1/1000 degrees C (-128C to +127C)
415 REG: 1C/bit, two's complement */
416 static u8 LM93_TEMP_TO_REG(long temp)
417 {
418 int ntemp = SENSORS_LIMIT(temp, LM93_TEMP_MIN, LM93_TEMP_MAX);
419 ntemp += (ntemp<0 ? -500 : 500);
420 return (u8)(ntemp / 1000);
421 }
422
423 /* Determine 4-bit temperature offset resolution */
424 static int LM93_TEMP_OFFSET_MODE_FROM_REG(u8 sfc2, int nr)
425 {
426 /* mode: 0 => 1C/bit, nonzero => 0.5C/bit */
427 return sfc2 & (nr < 2 ? 0x10 : 0x20);
428 }
429
430 /* This function is common to all 4-bit temperature offsets
431 reg is 4 bits right justified
432 mode 0 => 1C/bit, mode !0 => 0.5C/bit */
433 static int LM93_TEMP_OFFSET_FROM_REG(u8 reg, int mode)
434 {
435 return (reg & 0x0f) * (mode ? 5 : 10);
436 }
437
438 #define LM93_TEMP_OFFSET_MIN ( 0)
439 #define LM93_TEMP_OFFSET_MAX0 (150)
440 #define LM93_TEMP_OFFSET_MAX1 ( 75)
441
442 /* This function is common to all 4-bit temperature offsets
443 returns 4 bits right justified
444 mode 0 => 1C/bit, mode !0 => 0.5C/bit */
445 static u8 LM93_TEMP_OFFSET_TO_REG(int off, int mode)
446 {
447 int factor = mode ? 5 : 10;
448
449 off = SENSORS_LIMIT(off, LM93_TEMP_OFFSET_MIN,
450 mode ? LM93_TEMP_OFFSET_MAX1 : LM93_TEMP_OFFSET_MAX0);
451 return (u8)((off + factor/2) / factor);
452 }
453
454 /* 0 <= nr <= 3 */
455 static int LM93_TEMP_AUTO_OFFSET_FROM_REG(u8 reg, int nr, int mode)
456 {
457 /* temp1-temp2 (nr=0,1) use lower nibble */
458 if (nr < 2)
459 return LM93_TEMP_OFFSET_FROM_REG(reg & 0x0f, mode);
460
461 /* temp3-temp4 (nr=2,3) use upper nibble */
462 else
463 return LM93_TEMP_OFFSET_FROM_REG(reg >> 4 & 0x0f, mode);
464 }
465
466 /* TEMP: 1/10 degrees C (0C to +15C (mode 0) or +7.5C (mode non-zero))
467 REG: 1.0C/bit (mode 0) or 0.5C/bit (mode non-zero)
468 0 <= nr <= 3 */
469 static u8 LM93_TEMP_AUTO_OFFSET_TO_REG(u8 old, int off, int nr, int mode)
470 {
471 u8 new = LM93_TEMP_OFFSET_TO_REG(off, mode);
472
473 /* temp1-temp2 (nr=0,1) use lower nibble */
474 if (nr < 2)
475 return (old & 0xf0) | (new & 0x0f);
476
477 /* temp3-temp4 (nr=2,3) use upper nibble */
478 else
479 return (new << 4 & 0xf0) | (old & 0x0f);
480 }
481
482 static int LM93_AUTO_BOOST_HYST_FROM_REGS(struct lm93_data *data, int nr,
483 int mode)
484 {
485 u8 reg;
486
487 switch (nr) {
488 case 0:
489 reg = data->boost_hyst[0] & 0x0f;
490 break;
491 case 1:
492 reg = data->boost_hyst[0] >> 4 & 0x0f;
493 break;
494 case 2:
495 reg = data->boost_hyst[1] & 0x0f;
496 break;
497 case 3:
498 default:
499 reg = data->boost_hyst[1] >> 4 & 0x0f;
500 break;
501 }
502
503 return LM93_TEMP_FROM_REG(data->boost[nr]) -
504 LM93_TEMP_OFFSET_FROM_REG(reg, mode);
505 }
506
507 static u8 LM93_AUTO_BOOST_HYST_TO_REG(struct lm93_data *data, long hyst,
508 int nr, int mode)
509 {
510 u8 reg = LM93_TEMP_OFFSET_TO_REG(
511 (LM93_TEMP_FROM_REG(data->boost[nr]) - hyst), mode);
512
513 switch (nr) {
514 case 0:
515 reg = (data->boost_hyst[0] & 0xf0) | (reg & 0x0f);
516 break;
517 case 1:
518 reg = (reg << 4 & 0xf0) | (data->boost_hyst[0] & 0x0f);
519 break;
520 case 2:
521 reg = (data->boost_hyst[1] & 0xf0) | (reg & 0x0f);
522 break;
523 case 3:
524 default:
525 reg = (reg << 4 & 0xf0) | (data->boost_hyst[1] & 0x0f);
526 break;
527 }
528
529 return reg;
530 }
531
532 /* PWM: 0-255 per sensors documentation
533 REG: 0-13 as mapped below... right justified */
534 typedef enum { LM93_PWM_MAP_HI_FREQ, LM93_PWM_MAP_LO_FREQ } pwm_freq_t;
535 static int lm93_pwm_map[2][16] = {
536 {
537 0x00, /* 0.00% */ 0x40, /* 25.00% */
538 0x50, /* 31.25% */ 0x60, /* 37.50% */
539 0x70, /* 43.75% */ 0x80, /* 50.00% */
540 0x90, /* 56.25% */ 0xa0, /* 62.50% */
541 0xb0, /* 68.75% */ 0xc0, /* 75.00% */
542 0xd0, /* 81.25% */ 0xe0, /* 87.50% */
543 0xf0, /* 93.75% */ 0xff, /* 100.00% */
544 0xff, 0xff, /* 14, 15 are reserved and should never occur */
545 },
546 {
547 0x00, /* 0.00% */ 0x40, /* 25.00% */
548 0x49, /* 28.57% */ 0x52, /* 32.14% */
549 0x5b, /* 35.71% */ 0x64, /* 39.29% */
550 0x6d, /* 42.86% */ 0x76, /* 46.43% */
551 0x80, /* 50.00% */ 0x89, /* 53.57% */
552 0x92, /* 57.14% */ 0xb6, /* 71.43% */
553 0xdb, /* 85.71% */ 0xff, /* 100.00% */
554 0xff, 0xff, /* 14, 15 are reserved and should never occur */
555 },
556 };
557
558 static int LM93_PWM_FROM_REG(u8 reg, pwm_freq_t freq)
559 {
560 return lm93_pwm_map[freq][reg & 0x0f];
561 }
562
563 /* round up to nearest match */
564 static u8 LM93_PWM_TO_REG(int pwm, pwm_freq_t freq)
565 {
566 int i;
567 for (i = 0; i < 13; i++)
568 if (pwm <= lm93_pwm_map[freq][i])
569 break;
570
571 /* can fall through with i==13 */
572 return (u8)i;
573 }
574
575 static int LM93_FAN_FROM_REG(u16 regs)
576 {
577 const u16 count = le16_to_cpu(regs) >> 2;
578 return count==0 ? -1 : count==0x3fff ? 0: 1350000 / count;
579 }
580
581 /*
582 * RPM: (82.5 to 1350000)
583 * REG: 14-bits, LE, *left* justified
584 */
585 static u16 LM93_FAN_TO_REG(long rpm)
586 {
587 u16 count, regs;
588
589 if (rpm == 0) {
590 count = 0x3fff;
591 } else {
592 rpm = SENSORS_LIMIT(rpm, 1, 1000000);
593 count = SENSORS_LIMIT((1350000 + rpm) / rpm, 1, 0x3ffe);
594 }
595
596 regs = count << 2;
597 return cpu_to_le16(regs);
598 }
599
600 /* PWM FREQ: HZ
601 REG: 0-7 as mapped below */
602 static int lm93_pwm_freq_map[8] = {
603 22500, 96, 84, 72, 60, 48, 36, 12
604 };
605
606 static int LM93_PWM_FREQ_FROM_REG(u8 reg)
607 {
608 return lm93_pwm_freq_map[reg & 0x07];
609 }
610
611 /* round up to nearest match */
612 static u8 LM93_PWM_FREQ_TO_REG(int freq)
613 {
614 int i;
615 for (i = 7; i > 0; i--)
616 if (freq <= lm93_pwm_freq_map[i])
617 break;
618
619 /* can fall through with i==0 */
620 return (u8)i;
621 }
622
623 /* TIME: 1/100 seconds
624 * REG: 0-7 as mapped below */
625 static int lm93_spinup_time_map[8] = {
626 0, 10, 25, 40, 70, 100, 200, 400,
627 };
628
629 static int LM93_SPINUP_TIME_FROM_REG(u8 reg)
630 {
631 return lm93_spinup_time_map[reg >> 5 & 0x07];
632 }
633
634 /* round up to nearest match */
635 static u8 LM93_SPINUP_TIME_TO_REG(int time)
636 {
637 int i;
638 for (i = 0; i < 7; i++)
639 if (time <= lm93_spinup_time_map[i])
640 break;
641
642 /* can fall through with i==8 */
643 return (u8)i;
644 }
645
646 #define LM93_RAMP_MIN 0
647 #define LM93_RAMP_MAX 75
648
649 static int LM93_RAMP_FROM_REG(u8 reg)
650 {
651 return (reg & 0x0f) * 5;
652 }
653
654 /* RAMP: 1/100 seconds
655 REG: 50mS/bit 4-bits right justified */
656 static u8 LM93_RAMP_TO_REG(int ramp)
657 {
658 ramp = SENSORS_LIMIT(ramp, LM93_RAMP_MIN, LM93_RAMP_MAX);
659 return (u8)((ramp + 2) / 5);
660 }
661
662 /* PROCHOT: 0-255, 0 => 0%, 255 => > 96.6%
663 * REG: (same) */
664 static u8 LM93_PROCHOT_TO_REG(long prochot)
665 {
666 prochot = SENSORS_LIMIT(prochot, 0, 255);
667 return (u8)prochot;
668 }
669
670 /* PROCHOT-INTERVAL: 73 - 37200 (1/100 seconds)
671 * REG: 0-9 as mapped below */
672 static int lm93_interval_map[10] = {
673 73, 146, 290, 580, 1170, 2330, 4660, 9320, 18600, 37200,
674 };
675
676 static int LM93_INTERVAL_FROM_REG(u8 reg)
677 {
678 return lm93_interval_map[reg & 0x0f];
679 }
680
681 /* round up to nearest match */
682 static u8 LM93_INTERVAL_TO_REG(long interval)
683 {
684 int i;
685 for (i = 0; i < 9; i++)
686 if (interval <= lm93_interval_map[i])
687 break;
688
689 /* can fall through with i==9 */
690 return (u8)i;
691 }
692
693 /* GPIO: 0-255, GPIO0 is LSB
694 * REG: inverted */
695 static unsigned LM93_GPI_FROM_REG(u8 reg)
696 {
697 return ~reg & 0xff;
698 }
699
700 /* alarm bitmask definitions
701 The LM93 has nearly 64 bits of error status... I've pared that down to
702 what I think is a useful subset in order to fit it into 32 bits.
703
704 Especially note that the #VRD_HOT alarms are missing because we provide
705 that information as values in another sysfs file.
706
707 If libsensors is extended to support 64 bit values, this could be revisited.
708 */
709 #define LM93_ALARM_IN1 0x00000001
710 #define LM93_ALARM_IN2 0x00000002
711 #define LM93_ALARM_IN3 0x00000004
712 #define LM93_ALARM_IN4 0x00000008
713 #define LM93_ALARM_IN5 0x00000010
714 #define LM93_ALARM_IN6 0x00000020
715 #define LM93_ALARM_IN7 0x00000040
716 #define LM93_ALARM_IN8 0x00000080
717 #define LM93_ALARM_IN9 0x00000100
718 #define LM93_ALARM_IN10 0x00000200
719 #define LM93_ALARM_IN11 0x00000400
720 #define LM93_ALARM_IN12 0x00000800
721 #define LM93_ALARM_IN13 0x00001000
722 #define LM93_ALARM_IN14 0x00002000
723 #define LM93_ALARM_IN15 0x00004000
724 #define LM93_ALARM_IN16 0x00008000
725 #define LM93_ALARM_FAN1 0x00010000
726 #define LM93_ALARM_FAN2 0x00020000
727 #define LM93_ALARM_FAN3 0x00040000
728 #define LM93_ALARM_FAN4 0x00080000
729 #define LM93_ALARM_PH1_ERR 0x00100000
730 #define LM93_ALARM_PH2_ERR 0x00200000
731 #define LM93_ALARM_SCSI1_ERR 0x00400000
732 #define LM93_ALARM_SCSI2_ERR 0x00800000
733 #define LM93_ALARM_DVDDP1_ERR 0x01000000
734 #define LM93_ALARM_DVDDP2_ERR 0x02000000
735 #define LM93_ALARM_D1_ERR 0x04000000
736 #define LM93_ALARM_D2_ERR 0x08000000
737 #define LM93_ALARM_TEMP1 0x10000000
738 #define LM93_ALARM_TEMP2 0x20000000
739 #define LM93_ALARM_TEMP3 0x40000000
740
741 static unsigned LM93_ALARMS_FROM_REG(struct block1_t b1)
742 {
743 unsigned result;
744 result = b1.host_status_2 & 0x3f;
745
746 if (vccp_limit_type[0])
747 result |= (b1.host_status_4 & 0x10) << 2;
748 else
749 result |= b1.host_status_2 & 0x40;
750
751 if (vccp_limit_type[1])
752 result |= (b1.host_status_4 & 0x20) << 2;
753 else
754 result |= b1.host_status_2 & 0x80;
755
756 result |= b1.host_status_3 << 8;
757 result |= (b1.fan_status & 0x0f) << 16;
758 result |= (b1.p1_prochot_status & 0x80) << 13;
759 result |= (b1.p2_prochot_status & 0x80) << 14;
760 result |= (b1.host_status_4 & 0xfc) << 20;
761 result |= (b1.host_status_1 & 0x07) << 28;
762 return result;
763 }
764
765 #define MAX_RETRIES 5
766
767 static u8 lm93_read_byte(struct i2c_client *client, u8 reg)
768 {
769 int value, i;
770
771 /* retry in case of read errors */
772 for (i=1; i<=MAX_RETRIES; i++) {
773 if ((value = i2c_smbus_read_byte_data(client, reg)) >= 0) {
774 return value;
775 } else {
776 dev_warn(&client->dev,"lm93: read byte data failed, "
777 "address 0x%02x.\n", reg);
778 mdelay(i + 3);
779 }
780
781 }
782
783 /* <TODO> what to return in case of error? */
784 dev_err(&client->dev,"lm93: All read byte retries failed!!\n");
785 return 0;
786 }
787
788 static int lm93_write_byte(struct i2c_client *client, u8 reg, u8 value)
789 {
790 int result;
791
792 /* <TODO> how to handle write errors? */
793 result = i2c_smbus_write_byte_data(client, reg, value);
794
795 if (result < 0)
796 dev_warn(&client->dev,"lm93: write byte data failed, "
797 "0x%02x at address 0x%02x.\n", value, reg);
798
799 return result;
800 }
801
802 static u16 lm93_read_word(struct i2c_client *client, u8 reg)
803 {
804 int value, i;
805
806 /* retry in case of read errors */
807 for (i=1; i<=MAX_RETRIES; i++) {
808 if ((value = i2c_smbus_read_word_data(client, reg)) >= 0) {
809 return value;
810 } else {
811 dev_warn(&client->dev,"lm93: read word data failed, "
812 "address 0x%02x.\n", reg);
813 mdelay(i + 3);
814 }
815
816 }
817
818 /* <TODO> what to return in case of error? */
819 dev_err(&client->dev,"lm93: All read word retries failed!!\n");
820 return 0;
821 }
822
823 static int lm93_write_word(struct i2c_client *client, u8 reg, u16 value)
824 {
825 int result;
826
827 /* <TODO> how to handle write errors? */
828 result = i2c_smbus_write_word_data(client, reg, value);
829
830 if (result < 0)
831 dev_warn(&client->dev,"lm93: write word data failed, "
832 "0x%04x at address 0x%02x.\n", value, reg);
833
834 return result;
835 }
836
837 static u8 lm93_block_buffer[I2C_SMBUS_BLOCK_MAX];
838
839 /*
840 read block data into values, retry if not expected length
841 fbn => index to lm93_block_read_cmds table
842 (Fixed Block Number - section 14.5.2 of LM93 datasheet)
843 */
844 static void lm93_read_block(struct i2c_client *client, u8 fbn, u8 *values)
845 {
846 int i, result=0;
847
848 for (i = 1; i <= MAX_RETRIES; i++) {
849 result = i2c_smbus_read_block_data(client,
850 lm93_block_read_cmds[fbn].cmd, lm93_block_buffer);
851
852 if (result == lm93_block_read_cmds[fbn].len) {
853 break;
854 } else {
855 dev_warn(&client->dev,"lm93: block read data failed, "
856 "command 0x%02x.\n",
857 lm93_block_read_cmds[fbn].cmd);
858 mdelay(i + 3);
859 }
860 }
861
862 if (result == lm93_block_read_cmds[fbn].len) {
863 memcpy(values,lm93_block_buffer,lm93_block_read_cmds[fbn].len);
864 } else {
865 /* <TODO> what to do in case of error? */
866 }
867 }
868
869 static struct lm93_data *lm93_update_device(struct device *dev)
870 {
871 struct i2c_client *client = to_i2c_client(dev);
872 struct lm93_data *data = i2c_get_clientdata(client);
873 const unsigned long interval = HZ + (HZ / 2);
874
875 mutex_lock(&data->update_lock);
876
877 if (time_after(jiffies, data->last_updated + interval) ||
878 !data->valid) {
879
880 data->update(data, client);
881 data->last_updated = jiffies;
882 data->valid = 1;
883 }
884
885 mutex_unlock(&data->update_lock);
886 return data;
887 }
888
889 /* update routine for data that has no corresponding SMBus block command */
890 static void lm93_update_client_common(struct lm93_data *data,
891 struct i2c_client *client)
892 {
893 int i;
894 u8 *ptr;
895
896 /* temp1 - temp4: limits */
897 for (i = 0; i < 4; i++) {
898 data->temp_lim[i].min =
899 lm93_read_byte(client, LM93_REG_TEMP_MIN(i));
900 data->temp_lim[i].max =
901 lm93_read_byte(client, LM93_REG_TEMP_MAX(i));
902 }
903
904 /* config register */
905 data->config = lm93_read_byte(client, LM93_REG_CONFIG);
906
907 /* vid1 - vid2: values */
908 for (i = 0; i < 2; i++)
909 data->vid[i] = lm93_read_byte(client, LM93_REG_VID(i));
910
911 /* prochot1 - prochot2: limits */
912 for (i = 0; i < 2; i++)
913 data->prochot_max[i] = lm93_read_byte(client,
914 LM93_REG_PROCHOT_MAX(i));
915
916 /* vccp1 - vccp2: VID relative limits */
917 for (i = 0; i < 2; i++)
918 data->vccp_limits[i] = lm93_read_byte(client,
919 LM93_REG_VCCP_LIMIT_OFF(i));
920
921 /* GPIO input state */
922 data->gpi = lm93_read_byte(client, LM93_REG_GPI);
923
924 /* #PROCHOT override state */
925 data->prochot_override = lm93_read_byte(client,
926 LM93_REG_PROCHOT_OVERRIDE);
927
928 /* #PROCHOT intervals */
929 data->prochot_interval = lm93_read_byte(client,
930 LM93_REG_PROCHOT_INTERVAL);
931
932 /* Fan Boost Termperature registers */
933 for (i = 0; i < 4; i++)
934 data->boost[i] = lm93_read_byte(client, LM93_REG_BOOST(i));
935
936 /* Fan Boost Temperature Hyst. registers */
937 data->boost_hyst[0] = lm93_read_byte(client, LM93_REG_BOOST_HYST_12);
938 data->boost_hyst[1] = lm93_read_byte(client, LM93_REG_BOOST_HYST_34);
939
940 /* Temperature Zone Min. PWM & Hysteresis registers */
941 data->auto_pwm_min_hyst[0] =
942 lm93_read_byte(client, LM93_REG_PWM_MIN_HYST_12);
943 data->auto_pwm_min_hyst[1] =
944 lm93_read_byte(client, LM93_REG_PWM_MIN_HYST_34);
945
946 /* #PROCHOT & #VRDHOT PWM Ramp Control register */
947 data->pwm_ramp_ctl = lm93_read_byte(client, LM93_REG_PWM_RAMP_CTL);
948
949 /* misc setup registers */
950 data->sfc1 = lm93_read_byte(client, LM93_REG_SFC1);
951 data->sfc2 = lm93_read_byte(client, LM93_REG_SFC2);
952 data->sf_tach_to_pwm = lm93_read_byte(client,
953 LM93_REG_SF_TACH_TO_PWM);
954
955 /* write back alarm values to clear */
956 for (i = 0, ptr = (u8 *)(&data->block1); i < 8; i++)
957 lm93_write_byte(client, LM93_REG_HOST_ERROR_1 + i, *(ptr + i));
958 }
959
960 /* update routine which uses SMBus block data commands */
961 static void lm93_update_client_full(struct lm93_data *data,
962 struct i2c_client *client)
963 {
964 dev_dbg(&client->dev,"starting device update (block data enabled)\n");
965
966 /* in1 - in16: values & limits */
967 lm93_read_block(client, 3, (u8 *)(data->block3));
968 lm93_read_block(client, 7, (u8 *)(data->block7));
969
970 /* temp1 - temp4: values */
971 lm93_read_block(client, 2, (u8 *)(data->block2));
972
973 /* prochot1 - prochot2: values */
974 lm93_read_block(client, 4, (u8 *)(data->block4));
975
976 /* fan1 - fan4: values & limits */
977 lm93_read_block(client, 5, (u8 *)(data->block5));
978 lm93_read_block(client, 8, (u8 *)(data->block8));
979
980 /* pmw control registers */
981 lm93_read_block(client, 9, (u8 *)(data->block9));
982
983 /* alarm values */
984 lm93_read_block(client, 1, (u8 *)(&data->block1));
985
986 /* auto/pwm registers */
987 lm93_read_block(client, 10, (u8 *)(&data->block10));
988
989 lm93_update_client_common(data, client);
990 }
991
992 /* update routine which uses SMBus byte/word data commands only */
993 static void lm93_update_client_min(struct lm93_data *data,
994 struct i2c_client *client)
995 {
996 int i,j;
997 u8 *ptr;
998
999 dev_dbg(&client->dev,"starting device update (block data disabled)\n");
1000
1001 /* in1 - in16: values & limits */
1002 for (i = 0; i < 16; i++) {
1003 data->block3[i] =
1004 lm93_read_byte(client, LM93_REG_IN(i));
1005 data->block7[i].min =
1006 lm93_read_byte(client, LM93_REG_IN_MIN(i));
1007 data->block7[i].max =
1008 lm93_read_byte(client, LM93_REG_IN_MAX(i));
1009 }
1010
1011 /* temp1 - temp4: values */
1012 for (i = 0; i < 4; i++) {
1013 data->block2[i] =
1014 lm93_read_byte(client, LM93_REG_TEMP(i));
1015 }
1016
1017 /* prochot1 - prochot2: values */
1018 for (i = 0; i < 2; i++) {
1019 data->block4[i].cur =
1020 lm93_read_byte(client, LM93_REG_PROCHOT_CUR(i));
1021 data->block4[i].avg =
1022 lm93_read_byte(client, LM93_REG_PROCHOT_AVG(i));
1023 }
1024
1025 /* fan1 - fan4: values & limits */
1026 for (i = 0; i < 4; i++) {
1027 data->block5[i] =
1028 lm93_read_word(client, LM93_REG_FAN(i));
1029 data->block8[i] =
1030 lm93_read_word(client, LM93_REG_FAN_MIN(i));
1031 }
1032
1033 /* pwm control registers */
1034 for (i = 0; i < 2; i++) {
1035 for (j = 0; j < 4; j++) {
1036 data->block9[i][j] =
1037 lm93_read_byte(client, LM93_REG_PWM_CTL(i,j));
1038 }
1039 }
1040
1041 /* alarm values */
1042 for (i = 0, ptr = (u8 *)(&data->block1); i < 8; i++) {
1043 *(ptr + i) =
1044 lm93_read_byte(client, LM93_REG_HOST_ERROR_1 + i);
1045 }
1046
1047 /* auto/pwm (base temp) registers */
1048 for (i = 0; i < 4; i++) {
1049 data->block10.base[i] =
1050 lm93_read_byte(client, LM93_REG_TEMP_BASE(i));
1051 }
1052
1053 /* auto/pwm (offset temp) registers */
1054 for (i = 0; i < 12; i++) {
1055 data->block10.offset[i] =
1056 lm93_read_byte(client, LM93_REG_TEMP_OFFSET(i));
1057 }
1058
1059 lm93_update_client_common(data, client);
1060 }
1061
1062 /* following are the sysfs callback functions */
1063 static ssize_t show_in(struct device *dev, struct device_attribute *attr,
1064 char *buf)
1065 {
1066 int nr = (to_sensor_dev_attr(attr))->index;
1067
1068 struct lm93_data *data = lm93_update_device(dev);
1069 return sprintf(buf, "%d\n", LM93_IN_FROM_REG(nr, data->block3[nr]));
1070 }
1071
1072 static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, show_in, NULL, 0);
1073 static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, show_in, NULL, 1);
1074 static SENSOR_DEVICE_ATTR(in3_input, S_IRUGO, show_in, NULL, 2);
1075 static SENSOR_DEVICE_ATTR(in4_input, S_IRUGO, show_in, NULL, 3);
1076 static SENSOR_DEVICE_ATTR(in5_input, S_IRUGO, show_in, NULL, 4);
1077 static SENSOR_DEVICE_ATTR(in6_input, S_IRUGO, show_in, NULL, 5);
1078 static SENSOR_DEVICE_ATTR(in7_input, S_IRUGO, show_in, NULL, 6);
1079 static SENSOR_DEVICE_ATTR(in8_input, S_IRUGO, show_in, NULL, 7);
1080 static SENSOR_DEVICE_ATTR(in9_input, S_IRUGO, show_in, NULL, 8);
1081 static SENSOR_DEVICE_ATTR(in10_input, S_IRUGO, show_in, NULL, 9);
1082 static SENSOR_DEVICE_ATTR(in11_input, S_IRUGO, show_in, NULL, 10);
1083 static SENSOR_DEVICE_ATTR(in12_input, S_IRUGO, show_in, NULL, 11);
1084 static SENSOR_DEVICE_ATTR(in13_input, S_IRUGO, show_in, NULL, 12);
1085 static SENSOR_DEVICE_ATTR(in14_input, S_IRUGO, show_in, NULL, 13);
1086 static SENSOR_DEVICE_ATTR(in15_input, S_IRUGO, show_in, NULL, 14);
1087 static SENSOR_DEVICE_ATTR(in16_input, S_IRUGO, show_in, NULL, 15);
1088
1089 static ssize_t show_in_min(struct device *dev,
1090 struct device_attribute *attr, char *buf)
1091 {
1092 int nr = (to_sensor_dev_attr(attr))->index;
1093 struct lm93_data *data = lm93_update_device(dev);
1094 int vccp = nr - 6;
1095 long rc, vid;
1096
1097 if ((nr==6 || nr==7) && (vccp_limit_type[vccp])) {
1098 vid = LM93_VID_FROM_REG(data->vid[vccp]);
1099 rc = LM93_IN_MIN_FROM_REG(data->vccp_limits[vccp], vid);
1100 }
1101 else {
1102 rc = LM93_IN_FROM_REG(nr, data->block7[nr].min); \
1103 }
1104 return sprintf(buf, "%ld\n", rc); \
1105 }
1106
1107 static ssize_t store_in_min(struct device *dev, struct device_attribute *attr,
1108 const char *buf, size_t count)
1109 {
1110 int nr = (to_sensor_dev_attr(attr))->index;
1111 struct i2c_client *client = to_i2c_client(dev);
1112 struct lm93_data *data = i2c_get_clientdata(client);
1113 u32 val = simple_strtoul(buf, NULL, 10);
1114 int vccp = nr - 6;
1115 long vid;
1116
1117 mutex_lock(&data->update_lock);
1118 if ((nr==6 || nr==7) && (vccp_limit_type[vccp])) {
1119 vid = LM93_VID_FROM_REG(data->vid[vccp]);
1120 data->vccp_limits[vccp] = (data->vccp_limits[vccp] & 0xf0) |
1121 LM93_IN_REL_TO_REG(val, 0, vid);
1122 lm93_write_byte(client, LM93_REG_VCCP_LIMIT_OFF(vccp),
1123 data->vccp_limits[vccp]);
1124 }
1125 else {
1126 data->block7[nr].min = LM93_IN_TO_REG(nr,val);
1127 lm93_write_byte(client, LM93_REG_IN_MIN(nr),
1128 data->block7[nr].min);
1129 }
1130 mutex_unlock(&data->update_lock);
1131 return count;
1132 }
1133
1134 static SENSOR_DEVICE_ATTR(in1_min, S_IWUSR | S_IRUGO,
1135 show_in_min, store_in_min, 0);
1136 static SENSOR_DEVICE_ATTR(in2_min, S_IWUSR | S_IRUGO,
1137 show_in_min, store_in_min, 1);
1138 static SENSOR_DEVICE_ATTR(in3_min, S_IWUSR | S_IRUGO,
1139 show_in_min, store_in_min, 2);
1140 static SENSOR_DEVICE_ATTR(in4_min, S_IWUSR | S_IRUGO,
1141 show_in_min, store_in_min, 3);
1142 static SENSOR_DEVICE_ATTR(in5_min, S_IWUSR | S_IRUGO,
1143 show_in_min, store_in_min, 4);
1144 static SENSOR_DEVICE_ATTR(in6_min, S_IWUSR | S_IRUGO,
1145 show_in_min, store_in_min, 5);
1146 static SENSOR_DEVICE_ATTR(in7_min, S_IWUSR | S_IRUGO,
1147 show_in_min, store_in_min, 6);
1148 static SENSOR_DEVICE_ATTR(in8_min, S_IWUSR | S_IRUGO,
1149 show_in_min, store_in_min, 7);
1150 static SENSOR_DEVICE_ATTR(in9_min, S_IWUSR | S_IRUGO,
1151 show_in_min, store_in_min, 8);
1152 static SENSOR_DEVICE_ATTR(in10_min, S_IWUSR | S_IRUGO,
1153 show_in_min, store_in_min, 9);
1154 static SENSOR_DEVICE_ATTR(in11_min, S_IWUSR | S_IRUGO,
1155 show_in_min, store_in_min, 10);
1156 static SENSOR_DEVICE_ATTR(in12_min, S_IWUSR | S_IRUGO,
1157 show_in_min, store_in_min, 11);
1158 static SENSOR_DEVICE_ATTR(in13_min, S_IWUSR | S_IRUGO,
1159 show_in_min, store_in_min, 12);
1160 static SENSOR_DEVICE_ATTR(in14_min, S_IWUSR | S_IRUGO,
1161 show_in_min, store_in_min, 13);
1162 static SENSOR_DEVICE_ATTR(in15_min, S_IWUSR | S_IRUGO,
1163 show_in_min, store_in_min, 14);
1164 static SENSOR_DEVICE_ATTR(in16_min, S_IWUSR | S_IRUGO,
1165 show_in_min, store_in_min, 15);
1166
1167 static ssize_t show_in_max(struct device *dev,
1168 struct device_attribute *attr, char *buf)
1169 {
1170 int nr = (to_sensor_dev_attr(attr))->index;
1171 struct lm93_data *data = lm93_update_device(dev);
1172 int vccp = nr - 6;
1173 long rc, vid;
1174
1175 if ((nr==6 || nr==7) && (vccp_limit_type[vccp])) {
1176 vid = LM93_VID_FROM_REG(data->vid[vccp]);
1177 rc = LM93_IN_MAX_FROM_REG(data->vccp_limits[vccp],vid);
1178 }
1179 else {
1180 rc = LM93_IN_FROM_REG(nr,data->block7[nr].max); \
1181 }
1182 return sprintf(buf,"%ld\n",rc); \
1183 }
1184
1185 static ssize_t store_in_max(struct device *dev, struct device_attribute *attr,
1186 const char *buf, size_t count)
1187 {
1188 int nr = (to_sensor_dev_attr(attr))->index;
1189 struct i2c_client *client = to_i2c_client(dev);
1190 struct lm93_data *data = i2c_get_clientdata(client);
1191 u32 val = simple_strtoul(buf, NULL, 10);
1192 int vccp = nr - 6;
1193 long vid;
1194
1195 mutex_lock(&data->update_lock);
1196 if ((nr==6 || nr==7) && (vccp_limit_type[vccp])) {
1197 vid = LM93_VID_FROM_REG(data->vid[vccp]);
1198 data->vccp_limits[vccp] = (data->vccp_limits[vccp] & 0x0f) |
1199 LM93_IN_REL_TO_REG(val, 1, vid);
1200 lm93_write_byte(client, LM93_REG_VCCP_LIMIT_OFF(vccp),
1201 data->vccp_limits[vccp]);
1202 }
1203 else {
1204 data->block7[nr].max = LM93_IN_TO_REG(nr,val);
1205 lm93_write_byte(client, LM93_REG_IN_MAX(nr),
1206 data->block7[nr].max);
1207 }
1208 mutex_unlock(&data->update_lock);
1209 return count;
1210 }
1211
1212 static SENSOR_DEVICE_ATTR(in1_max, S_IWUSR | S_IRUGO,
1213 show_in_max, store_in_max, 0);
1214 static SENSOR_DEVICE_ATTR(in2_max, S_IWUSR | S_IRUGO,
1215 show_in_max, store_in_max, 1);
1216 static SENSOR_DEVICE_ATTR(in3_max, S_IWUSR | S_IRUGO,
1217 show_in_max, store_in_max, 2);
1218 static SENSOR_DEVICE_ATTR(in4_max, S_IWUSR | S_IRUGO,
1219 show_in_max, store_in_max, 3);
1220 static SENSOR_DEVICE_ATTR(in5_max, S_IWUSR | S_IRUGO,
1221 show_in_max, store_in_max, 4);
1222 static SENSOR_DEVICE_ATTR(in6_max, S_IWUSR | S_IRUGO,
1223 show_in_max, store_in_max, 5);
1224 static SENSOR_DEVICE_ATTR(in7_max, S_IWUSR | S_IRUGO,
1225 show_in_max, store_in_max, 6);
1226 static SENSOR_DEVICE_ATTR(in8_max, S_IWUSR | S_IRUGO,
1227 show_in_max, store_in_max, 7);
1228 static SENSOR_DEVICE_ATTR(in9_max, S_IWUSR | S_IRUGO,
1229 show_in_max, store_in_max, 8);
1230 static SENSOR_DEVICE_ATTR(in10_max, S_IWUSR | S_IRUGO,
1231 show_in_max, store_in_max, 9);
1232 static SENSOR_DEVICE_ATTR(in11_max, S_IWUSR | S_IRUGO,
1233 show_in_max, store_in_max, 10);
1234 static SENSOR_DEVICE_ATTR(in12_max, S_IWUSR | S_IRUGO,
1235 show_in_max, store_in_max, 11);
1236 static SENSOR_DEVICE_ATTR(in13_max, S_IWUSR | S_IRUGO,
1237 show_in_max, store_in_max, 12);
1238 static SENSOR_DEVICE_ATTR(in14_max, S_IWUSR | S_IRUGO,
1239 show_in_max, store_in_max, 13);
1240 static SENSOR_DEVICE_ATTR(in15_max, S_IWUSR | S_IRUGO,
1241 show_in_max, store_in_max, 14);
1242 static SENSOR_DEVICE_ATTR(in16_max, S_IWUSR | S_IRUGO,
1243 show_in_max, store_in_max, 15);
1244
1245 static ssize_t show_temp(struct device *dev,
1246 struct device_attribute *attr, char *buf)
1247 {
1248 int nr = (to_sensor_dev_attr(attr))->index;
1249 struct lm93_data *data = lm93_update_device(dev);
1250 return sprintf(buf,"%d\n",LM93_TEMP_FROM_REG(data->block2[nr]));
1251 }
1252
1253 static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_temp, NULL, 0);
1254 static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_temp, NULL, 1);
1255 static SENSOR_DEVICE_ATTR(temp3_input, S_IRUGO, show_temp, NULL, 2);
1256
1257 static ssize_t show_temp_min(struct device *dev,
1258 struct device_attribute *attr, char *buf)
1259 {
1260 int nr = (to_sensor_dev_attr(attr))->index;
1261 struct lm93_data *data = lm93_update_device(dev);
1262 return sprintf(buf,"%d\n",LM93_TEMP_FROM_REG(data->temp_lim[nr].min));
1263 }
1264
1265 static ssize_t store_temp_min(struct device *dev, struct device_attribute *attr,
1266 const char *buf, size_t count)
1267 {
1268 int nr = (to_sensor_dev_attr(attr))->index;
1269 struct i2c_client *client = to_i2c_client(dev);
1270 struct lm93_data *data = i2c_get_clientdata(client);
1271 long val = simple_strtol(buf, NULL, 10);
1272
1273 mutex_lock(&data->update_lock);
1274 data->temp_lim[nr].min = LM93_TEMP_TO_REG(val);
1275 lm93_write_byte(client, LM93_REG_TEMP_MIN(nr), data->temp_lim[nr].min);
1276 mutex_unlock(&data->update_lock);
1277 return count;
1278 }
1279
1280 static SENSOR_DEVICE_ATTR(temp1_min, S_IWUSR | S_IRUGO,
1281 show_temp_min, store_temp_min, 0);
1282 static SENSOR_DEVICE_ATTR(temp2_min, S_IWUSR | S_IRUGO,
1283 show_temp_min, store_temp_min, 1);
1284 static SENSOR_DEVICE_ATTR(temp3_min, S_IWUSR | S_IRUGO,
1285 show_temp_min, store_temp_min, 2);
1286
1287 static ssize_t show_temp_max(struct device *dev,
1288 struct device_attribute *attr, char *buf)
1289 {
1290 int nr = (to_sensor_dev_attr(attr))->index;
1291 struct lm93_data *data = lm93_update_device(dev);
1292 return sprintf(buf,"%d\n",LM93_TEMP_FROM_REG(data->temp_lim[nr].max));
1293 }
1294
1295 static ssize_t store_temp_max(struct device *dev, struct device_attribute *attr,
1296 const char *buf, size_t count)
1297 {
1298 int nr = (to_sensor_dev_attr(attr))->index;
1299 struct i2c_client *client = to_i2c_client(dev);
1300 struct lm93_data *data = i2c_get_clientdata(client);
1301 long val = simple_strtol(buf, NULL, 10);
1302
1303 mutex_lock(&data->update_lock);
1304 data->temp_lim[nr].max = LM93_TEMP_TO_REG(val);
1305 lm93_write_byte(client, LM93_REG_TEMP_MAX(nr), data->temp_lim[nr].max);
1306 mutex_unlock(&data->update_lock);
1307 return count;
1308 }
1309
1310 static SENSOR_DEVICE_ATTR(temp1_max, S_IWUSR | S_IRUGO,
1311 show_temp_max, store_temp_max, 0);
1312 static SENSOR_DEVICE_ATTR(temp2_max, S_IWUSR | S_IRUGO,
1313 show_temp_max, store_temp_max, 1);
1314 static SENSOR_DEVICE_ATTR(temp3_max, S_IWUSR | S_IRUGO,
1315 show_temp_max, store_temp_max, 2);
1316
1317 static ssize_t show_temp_auto_base(struct device *dev,
1318 struct device_attribute *attr, char *buf)
1319 {
1320 int nr = (to_sensor_dev_attr(attr))->index;
1321 struct lm93_data *data = lm93_update_device(dev);
1322 return sprintf(buf,"%d\n",LM93_TEMP_FROM_REG(data->block10.base[nr]));
1323 }
1324
1325 static ssize_t store_temp_auto_base(struct device *dev,
1326 struct device_attribute *attr,
1327 const char *buf, size_t count)
1328 {
1329 int nr = (to_sensor_dev_attr(attr))->index;
1330 struct i2c_client *client = to_i2c_client(dev);
1331 struct lm93_data *data = i2c_get_clientdata(client);
1332 long val = simple_strtol(buf, NULL, 10);
1333
1334 mutex_lock(&data->update_lock);
1335 data->block10.base[nr] = LM93_TEMP_TO_REG(val);
1336 lm93_write_byte(client, LM93_REG_TEMP_BASE(nr), data->block10.base[nr]);
1337 mutex_unlock(&data->update_lock);
1338 return count;
1339 }
1340
1341 static SENSOR_DEVICE_ATTR(temp1_auto_base, S_IWUSR | S_IRUGO,
1342 show_temp_auto_base, store_temp_auto_base, 0);
1343 static SENSOR_DEVICE_ATTR(temp2_auto_base, S_IWUSR | S_IRUGO,
1344 show_temp_auto_base, store_temp_auto_base, 1);
1345 static SENSOR_DEVICE_ATTR(temp3_auto_base, S_IWUSR | S_IRUGO,
1346 show_temp_auto_base, store_temp_auto_base, 2);
1347
1348 static ssize_t show_temp_auto_boost(struct device *dev,
1349 struct device_attribute *attr,char *buf)
1350 {
1351 int nr = (to_sensor_dev_attr(attr))->index;
1352 struct lm93_data *data = lm93_update_device(dev);
1353 return sprintf(buf,"%d\n",LM93_TEMP_FROM_REG(data->boost[nr]));
1354 }
1355
1356 static ssize_t store_temp_auto_boost(struct device *dev,
1357 struct device_attribute *attr,
1358 const char *buf, size_t count)
1359 {
1360 int nr = (to_sensor_dev_attr(attr))->index;
1361 struct i2c_client *client = to_i2c_client(dev);
1362 struct lm93_data *data = i2c_get_clientdata(client);
1363 long val = simple_strtol(buf, NULL, 10);
1364
1365 mutex_lock(&data->update_lock);
1366 data->boost[nr] = LM93_TEMP_TO_REG(val);
1367 lm93_write_byte(client, LM93_REG_BOOST(nr), data->boost[nr]);
1368 mutex_unlock(&data->update_lock);
1369 return count;
1370 }
1371
1372 static SENSOR_DEVICE_ATTR(temp1_auto_boost, S_IWUSR | S_IRUGO,
1373 show_temp_auto_boost, store_temp_auto_boost, 0);
1374 static SENSOR_DEVICE_ATTR(temp2_auto_boost, S_IWUSR | S_IRUGO,
1375 show_temp_auto_boost, store_temp_auto_boost, 1);
1376 static SENSOR_DEVICE_ATTR(temp3_auto_boost, S_IWUSR | S_IRUGO,
1377 show_temp_auto_boost, store_temp_auto_boost, 2);
1378
1379 static ssize_t show_temp_auto_boost_hyst(struct device *dev,
1380 struct device_attribute *attr,
1381 char *buf)
1382 {
1383 int nr = (to_sensor_dev_attr(attr))->index;
1384 struct lm93_data *data = lm93_update_device(dev);
1385 int mode = LM93_TEMP_OFFSET_MODE_FROM_REG(data->sfc2, nr);
1386 return sprintf(buf,"%d\n",
1387 LM93_AUTO_BOOST_HYST_FROM_REGS(data, nr, mode));
1388 }
1389
1390 static ssize_t store_temp_auto_boost_hyst(struct device *dev,
1391 struct device_attribute *attr,
1392 const char *buf, size_t count)
1393 {
1394 int nr = (to_sensor_dev_attr(attr))->index;
1395 struct i2c_client *client = to_i2c_client(dev);
1396 struct lm93_data *data = i2c_get_clientdata(client);
1397 u32 val = simple_strtoul(buf, NULL, 10);
1398
1399 mutex_lock(&data->update_lock);
1400 /* force 0.5C/bit mode */
1401 data->sfc2 = lm93_read_byte(client, LM93_REG_SFC2);
1402 data->sfc2 |= ((nr < 2) ? 0x10 : 0x20);
1403 lm93_write_byte(client, LM93_REG_SFC2, data->sfc2);
1404 data->boost_hyst[nr/2] = LM93_AUTO_BOOST_HYST_TO_REG(data, val, nr, 1);
1405 lm93_write_byte(client, LM93_REG_BOOST_HYST(nr),
1406 data->boost_hyst[nr/2]);
1407 mutex_unlock(&data->update_lock);
1408 return count;
1409 }
1410
1411 static SENSOR_DEVICE_ATTR(temp1_auto_boost_hyst, S_IWUSR | S_IRUGO,
1412 show_temp_auto_boost_hyst,
1413 store_temp_auto_boost_hyst, 0);
1414 static SENSOR_DEVICE_ATTR(temp2_auto_boost_hyst, S_IWUSR | S_IRUGO,
1415 show_temp_auto_boost_hyst,
1416 store_temp_auto_boost_hyst, 1);
1417 static SENSOR_DEVICE_ATTR(temp3_auto_boost_hyst, S_IWUSR | S_IRUGO,
1418 show_temp_auto_boost_hyst,
1419 store_temp_auto_boost_hyst, 2);
1420
1421 static ssize_t show_temp_auto_offset(struct device *dev,
1422 struct device_attribute *attr, char *buf)
1423 {
1424 struct sensor_device_attribute_2 *s_attr = to_sensor_dev_attr_2(attr);
1425 int nr = s_attr->index;
1426 int ofs = s_attr->nr;
1427 struct lm93_data *data = lm93_update_device(dev);
1428 int mode = LM93_TEMP_OFFSET_MODE_FROM_REG(data->sfc2, nr);
1429 return sprintf(buf,"%d\n",
1430 LM93_TEMP_AUTO_OFFSET_FROM_REG(data->block10.offset[ofs],
1431 nr,mode));
1432 }
1433
1434 static ssize_t store_temp_auto_offset(struct device *dev,
1435 struct device_attribute *attr,
1436 const char *buf, size_t count)
1437 {
1438 struct sensor_device_attribute_2 *s_attr = to_sensor_dev_attr_2(attr);
1439 int nr = s_attr->index;
1440 int ofs = s_attr->nr;
1441 struct i2c_client *client = to_i2c_client(dev);
1442 struct lm93_data *data = i2c_get_clientdata(client);
1443 u32 val = simple_strtoul(buf, NULL, 10);
1444
1445 mutex_lock(&data->update_lock);
1446 /* force 0.5C/bit mode */
1447 data->sfc2 = lm93_read_byte(client, LM93_REG_SFC2);
1448 data->sfc2 |= ((nr < 2) ? 0x10 : 0x20);
1449 lm93_write_byte(client, LM93_REG_SFC2, data->sfc2);
1450 data->block10.offset[ofs] = LM93_TEMP_AUTO_OFFSET_TO_REG(
1451 data->block10.offset[ofs], val, nr, 1);
1452 lm93_write_byte(client, LM93_REG_TEMP_OFFSET(ofs),
1453 data->block10.offset[ofs]);
1454 mutex_unlock(&data->update_lock);
1455 return count;
1456 }
1457
1458 static SENSOR_DEVICE_ATTR_2(temp1_auto_offset1, S_IWUSR | S_IRUGO,
1459 show_temp_auto_offset, store_temp_auto_offset, 0, 0);
1460 static SENSOR_DEVICE_ATTR_2(temp1_auto_offset2, S_IWUSR | S_IRUGO,
1461 show_temp_auto_offset, store_temp_auto_offset, 1, 0);
1462 static SENSOR_DEVICE_ATTR_2(temp1_auto_offset3, S_IWUSR | S_IRUGO,
1463 show_temp_auto_offset, store_temp_auto_offset, 2, 0);
1464 static SENSOR_DEVICE_ATTR_2(temp1_auto_offset4, S_IWUSR | S_IRUGO,
1465 show_temp_auto_offset, store_temp_auto_offset, 3, 0);
1466 static SENSOR_DEVICE_ATTR_2(temp1_auto_offset5, S_IWUSR | S_IRUGO,
1467 show_temp_auto_offset, store_temp_auto_offset, 4, 0);
1468 static SENSOR_DEVICE_ATTR_2(temp1_auto_offset6, S_IWUSR | S_IRUGO,
1469 show_temp_auto_offset, store_temp_auto_offset, 5, 0);
1470 static SENSOR_DEVICE_ATTR_2(temp1_auto_offset7, S_IWUSR | S_IRUGO,
1471 show_temp_auto_offset, store_temp_auto_offset, 6, 0);
1472 static SENSOR_DEVICE_ATTR_2(temp1_auto_offset8, S_IWUSR | S_IRUGO,
1473 show_temp_auto_offset, store_temp_auto_offset, 7, 0);
1474 static SENSOR_DEVICE_ATTR_2(temp1_auto_offset9, S_IWUSR | S_IRUGO,
1475 show_temp_auto_offset, store_temp_auto_offset, 8, 0);
1476 static SENSOR_DEVICE_ATTR_2(temp1_auto_offset10, S_IWUSR | S_IRUGO,
1477 show_temp_auto_offset, store_temp_auto_offset, 9, 0);
1478 static SENSOR_DEVICE_ATTR_2(temp1_auto_offset11, S_IWUSR | S_IRUGO,
1479 show_temp_auto_offset, store_temp_auto_offset, 10, 0);
1480 static SENSOR_DEVICE_ATTR_2(temp1_auto_offset12, S_IWUSR | S_IRUGO,
1481 show_temp_auto_offset, store_temp_auto_offset, 11, 0);
1482 static SENSOR_DEVICE_ATTR_2(temp2_auto_offset1, S_IWUSR | S_IRUGO,
1483 show_temp_auto_offset, store_temp_auto_offset, 0, 1);
1484 static SENSOR_DEVICE_ATTR_2(temp2_auto_offset2, S_IWUSR | S_IRUGO,
1485 show_temp_auto_offset, store_temp_auto_offset, 1, 1);
1486 static SENSOR_DEVICE_ATTR_2(temp2_auto_offset3, S_IWUSR | S_IRUGO,
1487 show_temp_auto_offset, store_temp_auto_offset, 2, 1);
1488 static SENSOR_DEVICE_ATTR_2(temp2_auto_offset4, S_IWUSR | S_IRUGO,
1489 show_temp_auto_offset, store_temp_auto_offset, 3, 1);
1490 static SENSOR_DEVICE_ATTR_2(temp2_auto_offset5, S_IWUSR | S_IRUGO,
1491 show_temp_auto_offset, store_temp_auto_offset, 4, 1);
1492 static SENSOR_DEVICE_ATTR_2(temp2_auto_offset6, S_IWUSR | S_IRUGO,
1493 show_temp_auto_offset, store_temp_auto_offset, 5, 1);
1494 static SENSOR_DEVICE_ATTR_2(temp2_auto_offset7, S_IWUSR | S_IRUGO,
1495 show_temp_auto_offset, store_temp_auto_offset, 6, 1);
1496 static SENSOR_DEVICE_ATTR_2(temp2_auto_offset8, S_IWUSR | S_IRUGO,
1497 show_temp_auto_offset, store_temp_auto_offset, 7, 1);
1498 static SENSOR_DEVICE_ATTR_2(temp2_auto_offset9, S_IWUSR | S_IRUGO,
1499 show_temp_auto_offset, store_temp_auto_offset, 8, 1);
1500 static SENSOR_DEVICE_ATTR_2(temp2_auto_offset10, S_IWUSR | S_IRUGO,
1501 show_temp_auto_offset, store_temp_auto_offset, 9, 1);
1502 static SENSOR_DEVICE_ATTR_2(temp2_auto_offset11, S_IWUSR | S_IRUGO,
1503 show_temp_auto_offset, store_temp_auto_offset, 10, 1);
1504 static SENSOR_DEVICE_ATTR_2(temp2_auto_offset12, S_IWUSR | S_IRUGO,
1505 show_temp_auto_offset, store_temp_auto_offset, 11, 1);
1506 static SENSOR_DEVICE_ATTR_2(temp3_auto_offset1, S_IWUSR | S_IRUGO,
1507 show_temp_auto_offset, store_temp_auto_offset, 0, 2);
1508 static SENSOR_DEVICE_ATTR_2(temp3_auto_offset2, S_IWUSR | S_IRUGO,
1509 show_temp_auto_offset, store_temp_auto_offset, 1, 2);
1510 static SENSOR_DEVICE_ATTR_2(temp3_auto_offset3, S_IWUSR | S_IRUGO,
1511 show_temp_auto_offset, store_temp_auto_offset, 2, 2);
1512 static SENSOR_DEVICE_ATTR_2(temp3_auto_offset4, S_IWUSR | S_IRUGO,
1513 show_temp_auto_offset, store_temp_auto_offset, 3, 2);
1514 static SENSOR_DEVICE_ATTR_2(temp3_auto_offset5, S_IWUSR | S_IRUGO,
1515 show_temp_auto_offset, store_temp_auto_offset, 4, 2);
1516 static SENSOR_DEVICE_ATTR_2(temp3_auto_offset6, S_IWUSR | S_IRUGO,
1517 show_temp_auto_offset, store_temp_auto_offset, 5, 2);
1518 static SENSOR_DEVICE_ATTR_2(temp3_auto_offset7, S_IWUSR | S_IRUGO,
1519 show_temp_auto_offset, store_temp_auto_offset, 6, 2);
1520 static SENSOR_DEVICE_ATTR_2(temp3_auto_offset8, S_IWUSR | S_IRUGO,
1521 show_temp_auto_offset, store_temp_auto_offset, 7, 2);
1522 static SENSOR_DEVICE_ATTR_2(temp3_auto_offset9, S_IWUSR | S_IRUGO,
1523 show_temp_auto_offset, store_temp_auto_offset, 8, 2);
1524 static SENSOR_DEVICE_ATTR_2(temp3_auto_offset10, S_IWUSR | S_IRUGO,
1525 show_temp_auto_offset, store_temp_auto_offset, 9, 2);
1526 static SENSOR_DEVICE_ATTR_2(temp3_auto_offset11, S_IWUSR | S_IRUGO,
1527 show_temp_auto_offset, store_temp_auto_offset, 10, 2);
1528 static SENSOR_DEVICE_ATTR_2(temp3_auto_offset12, S_IWUSR | S_IRUGO,
1529 show_temp_auto_offset, store_temp_auto_offset, 11, 2);
1530
1531 static ssize_t show_temp_auto_pwm_min(struct device *dev,
1532 struct device_attribute *attr, char *buf)
1533 {
1534 int nr = (to_sensor_dev_attr(attr))->index;
1535 u8 reg, ctl4;
1536 struct lm93_data *data = lm93_update_device(dev);
1537 reg = data->auto_pwm_min_hyst[nr/2] >> 4 & 0x0f;
1538 ctl4 = data->block9[nr][LM93_PWM_CTL4];
1539 return sprintf(buf,"%d\n",LM93_PWM_FROM_REG(reg, (ctl4 & 0x07) ?
1540 LM93_PWM_MAP_LO_FREQ : LM93_PWM_MAP_HI_FREQ));
1541 }
1542
1543 static ssize_t store_temp_auto_pwm_min(struct device *dev,
1544 struct device_attribute *attr,
1545 const char *buf, size_t count)
1546 {
1547 int nr = (to_sensor_dev_attr(attr))->index;
1548 struct i2c_client *client = to_i2c_client(dev);
1549 struct lm93_data *data = i2c_get_clientdata(client);
1550 u32 val = simple_strtoul(buf, NULL, 10);
1551 u8 reg, ctl4;
1552
1553 mutex_lock(&data->update_lock);
1554 reg = lm93_read_byte(client, LM93_REG_PWM_MIN_HYST(nr));
1555 ctl4 = lm93_read_byte(client, LM93_REG_PWM_CTL(nr,LM93_PWM_CTL4));
1556 reg = (reg & 0x0f) |
1557 LM93_PWM_TO_REG(val, (ctl4 & 0x07) ?
1558 LM93_PWM_MAP_LO_FREQ :
1559 LM93_PWM_MAP_HI_FREQ) << 4;
1560 data->auto_pwm_min_hyst[nr/2] = reg;
1561 lm93_write_byte(client, LM93_REG_PWM_MIN_HYST(nr), reg);
1562 mutex_unlock(&data->update_lock);
1563 return count;
1564 }
1565
1566 static SENSOR_DEVICE_ATTR(temp1_auto_pwm_min, S_IWUSR | S_IRUGO,
1567 show_temp_auto_pwm_min,
1568 store_temp_auto_pwm_min, 0);
1569 static SENSOR_DEVICE_ATTR(temp2_auto_pwm_min, S_IWUSR | S_IRUGO,
1570 show_temp_auto_pwm_min,
1571 store_temp_auto_pwm_min, 1);
1572 static SENSOR_DEVICE_ATTR(temp3_auto_pwm_min, S_IWUSR | S_IRUGO,
1573 show_temp_auto_pwm_min,
1574 store_temp_auto_pwm_min, 2);
1575
1576 static ssize_t show_temp_auto_offset_hyst(struct device *dev,
1577 struct device_attribute *attr, char *buf)
1578 {
1579 int nr = (to_sensor_dev_attr(attr))->index;
1580 struct lm93_data *data = lm93_update_device(dev);
1581 int mode = LM93_TEMP_OFFSET_MODE_FROM_REG(data->sfc2, nr);
1582 return sprintf(buf,"%d\n",LM93_TEMP_OFFSET_FROM_REG(
1583 data->auto_pwm_min_hyst[nr/2], mode));
1584 }
1585
1586 static ssize_t store_temp_auto_offset_hyst(struct device *dev,
1587 struct device_attribute *attr,
1588 const char *buf, size_t count)
1589 {
1590 int nr = (to_sensor_dev_attr(attr))->index;
1591 struct i2c_client *client = to_i2c_client(dev);
1592 struct lm93_data *data = i2c_get_clientdata(client);
1593 u32 val = simple_strtoul(buf, NULL, 10);
1594 u8 reg;
1595
1596 mutex_lock(&data->update_lock);
1597 /* force 0.5C/bit mode */
1598 data->sfc2 = lm93_read_byte(client, LM93_REG_SFC2);
1599 data->sfc2 |= ((nr < 2) ? 0x10 : 0x20);
1600 lm93_write_byte(client, LM93_REG_SFC2, data->sfc2);
1601 reg = data->auto_pwm_min_hyst[nr/2];
1602 reg = (reg & 0xf0) | (LM93_TEMP_OFFSET_TO_REG(val, 1) & 0x0f);
1603 data->auto_pwm_min_hyst[nr/2] = reg;
1604 lm93_write_byte(client, LM93_REG_PWM_MIN_HYST(nr), reg);
1605 mutex_unlock(&data->update_lock);
1606 return count;
1607 }
1608
1609 static SENSOR_DEVICE_ATTR(temp1_auto_offset_hyst, S_IWUSR | S_IRUGO,
1610 show_temp_auto_offset_hyst,
1611 store_temp_auto_offset_hyst, 0);
1612 static SENSOR_DEVICE_ATTR(temp2_auto_offset_hyst, S_IWUSR | S_IRUGO,
1613 show_temp_auto_offset_hyst,
1614 store_temp_auto_offset_hyst, 1);
1615 static SENSOR_DEVICE_ATTR(temp3_auto_offset_hyst, S_IWUSR | S_IRUGO,
1616 show_temp_auto_offset_hyst,
1617 store_temp_auto_offset_hyst, 2);
1618
1619 static ssize_t show_fan_input(struct device *dev,
1620 struct device_attribute *attr, char *buf)
1621 {
1622 struct sensor_device_attribute *s_attr = to_sensor_dev_attr(attr);
1623 int nr = s_attr->index;
1624 struct lm93_data *data = lm93_update_device(dev);
1625
1626 return sprintf(buf,"%d\n",LM93_FAN_FROM_REG(data->block5[nr]));
1627 }
1628
1629 static SENSOR_DEVICE_ATTR(fan1_input, S_IRUGO, show_fan_input, NULL, 0);
1630 static SENSOR_DEVICE_ATTR(fan2_input, S_IRUGO, show_fan_input, NULL, 1);
1631 static SENSOR_DEVICE_ATTR(fan3_input, S_IRUGO, show_fan_input, NULL, 2);
1632 static SENSOR_DEVICE_ATTR(fan4_input, S_IRUGO, show_fan_input, NULL, 3);
1633
1634 static ssize_t show_fan_min(struct device *dev,
1635 struct device_attribute *attr, char *buf)
1636 {
1637 int nr = (to_sensor_dev_attr(attr))->index;
1638 struct lm93_data *data = lm93_update_device(dev);
1639
1640 return sprintf(buf,"%d\n",LM93_FAN_FROM_REG(data->block8[nr]));
1641 }
1642
1643 static ssize_t store_fan_min(struct device *dev, struct device_attribute *attr,
1644 const char *buf, size_t count)
1645 {
1646 int nr = (to_sensor_dev_attr(attr))->index;
1647 struct i2c_client *client = to_i2c_client(dev);
1648 struct lm93_data *data = i2c_get_clientdata(client);
1649 u32 val = simple_strtoul(buf, NULL, 10);
1650
1651 mutex_lock(&data->update_lock);
1652 data->block8[nr] = LM93_FAN_TO_REG(val);
1653 lm93_write_word(client,LM93_REG_FAN_MIN(nr),data->block8[nr]);
1654 mutex_unlock(&data->update_lock);
1655 return count;
1656 }
1657
1658 static SENSOR_DEVICE_ATTR(fan1_min, S_IWUSR | S_IRUGO,
1659 show_fan_min, store_fan_min, 0);
1660 static SENSOR_DEVICE_ATTR(fan2_min, S_IWUSR | S_IRUGO,
1661 show_fan_min, store_fan_min, 1);
1662 static SENSOR_DEVICE_ATTR(fan3_min, S_IWUSR | S_IRUGO,
1663 show_fan_min, store_fan_min, 2);
1664 static SENSOR_DEVICE_ATTR(fan4_min, S_IWUSR | S_IRUGO,
1665 show_fan_min, store_fan_min, 3);
1666
1667 /* some tedious bit-twiddling here to deal with the register format:
1668
1669 data->sf_tach_to_pwm: (tach to pwm mapping bits)
1670
1671 bit | 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0
1672 T4:P2 T4:P1 T3:P2 T3:P1 T2:P2 T2:P1 T1:P2 T1:P1
1673
1674 data->sfc2: (enable bits)
1675
1676 bit | 3 | 2 | 1 | 0
1677 T4 T3 T2 T1
1678 */
1679
1680 static ssize_t show_fan_smart_tach(struct device *dev,
1681 struct device_attribute *attr, char *buf)
1682 {
1683 int nr = (to_sensor_dev_attr(attr))->index;
1684 struct lm93_data *data = lm93_update_device(dev);
1685 long rc = 0;
1686 int mapping;
1687
1688 /* extract the relevant mapping */
1689 mapping = (data->sf_tach_to_pwm >> (nr * 2)) & 0x03;
1690
1691 /* if there's a mapping and it's enabled */
1692 if (mapping && ((data->sfc2 >> nr) & 0x01))
1693 rc = mapping;
1694 return sprintf(buf,"%ld\n",rc);
1695 }
1696
1697 /* helper function - must grab data->update_lock before calling
1698 fan is 0-3, indicating fan1-fan4 */
1699 static void lm93_write_fan_smart_tach(struct i2c_client *client,
1700 struct lm93_data *data, int fan, long value)
1701 {
1702 /* insert the new mapping and write it out */
1703 data->sf_tach_to_pwm = lm93_read_byte(client, LM93_REG_SF_TACH_TO_PWM);
1704 data->sf_tach_to_pwm &= ~(0x3 << fan * 2);
1705 data->sf_tach_to_pwm |= value << fan * 2;
1706 lm93_write_byte(client, LM93_REG_SF_TACH_TO_PWM, data->sf_tach_to_pwm);
1707
1708 /* insert the enable bit and write it out */
1709 data->sfc2 = lm93_read_byte(client, LM93_REG_SFC2);
1710 if (value)
1711 data->sfc2 |= 1 << fan;
1712 else
1713 data->sfc2 &= ~(1 << fan);
1714 lm93_write_byte(client, LM93_REG_SFC2, data->sfc2);
1715 }
1716
1717 static ssize_t store_fan_smart_tach(struct device *dev,
1718 struct device_attribute *attr,
1719 const char *buf, size_t count)
1720 {
1721 int nr = (to_sensor_dev_attr(attr))->index;
1722 struct i2c_client *client = to_i2c_client(dev);
1723 struct lm93_data *data = i2c_get_clientdata(client);
1724 u32 val = simple_strtoul(buf, NULL, 10);
1725
1726 mutex_lock(&data->update_lock);
1727 /* sanity test, ignore the write otherwise */
1728 if (0 <= val && val <= 2) {
1729 /* can't enable if pwm freq is 22.5KHz */
1730 if (val) {
1731 u8 ctl4 = lm93_read_byte(client,
1732 LM93_REG_PWM_CTL(val-1,LM93_PWM_CTL4));
1733 if ((ctl4 & 0x07) == 0)
1734 val = 0;
1735 }
1736 lm93_write_fan_smart_tach(client, data, nr, val);
1737 }
1738 mutex_unlock(&data->update_lock);
1739 return count;
1740 }
1741
1742 static SENSOR_DEVICE_ATTR(fan1_smart_tach, S_IWUSR | S_IRUGO,
1743 show_fan_smart_tach, store_fan_smart_tach, 0);
1744 static SENSOR_DEVICE_ATTR(fan2_smart_tach, S_IWUSR | S_IRUGO,
1745 show_fan_smart_tach, store_fan_smart_tach, 1);
1746 static SENSOR_DEVICE_ATTR(fan3_smart_tach, S_IWUSR | S_IRUGO,
1747 show_fan_smart_tach, store_fan_smart_tach, 2);
1748 static SENSOR_DEVICE_ATTR(fan4_smart_tach, S_IWUSR | S_IRUGO,
1749 show_fan_smart_tach, store_fan_smart_tach, 3);
1750
1751 static ssize_t show_pwm(struct device *dev, struct device_attribute *attr,
1752 char *buf)
1753 {
1754 int nr = (to_sensor_dev_attr(attr))->index;
1755 struct lm93_data *data = lm93_update_device(dev);
1756 u8 ctl2, ctl4;
1757 long rc;
1758
1759 ctl2 = data->block9[nr][LM93_PWM_CTL2];
1760 ctl4 = data->block9[nr][LM93_PWM_CTL4];
1761 if (ctl2 & 0x01) /* show user commanded value if enabled */
1762 rc = data->pwm_override[nr];
1763 else /* show present h/w value if manual pwm disabled */
1764 rc = LM93_PWM_FROM_REG(ctl2 >> 4, (ctl4 & 0x07) ?
1765 LM93_PWM_MAP_LO_FREQ : LM93_PWM_MAP_HI_FREQ);
1766 return sprintf(buf,"%ld\n",rc);
1767 }
1768
1769 static ssize_t store_pwm(struct device *dev, struct device_attribute *attr,
1770 const char *buf, size_t count)
1771 {
1772 int nr = (to_sensor_dev_attr(attr))->index;
1773 struct i2c_client *client = to_i2c_client(dev);
1774 struct lm93_data *data = i2c_get_clientdata(client);
1775 u32 val = simple_strtoul(buf, NULL, 10);
1776 u8 ctl2, ctl4;
1777
1778 mutex_lock(&data->update_lock);
1779 ctl2 = lm93_read_byte(client,LM93_REG_PWM_CTL(nr,LM93_PWM_CTL2));
1780 ctl4 = lm93_read_byte(client, LM93_REG_PWM_CTL(nr,LM93_PWM_CTL4));
1781 ctl2 = (ctl2 & 0x0f) | LM93_PWM_TO_REG(val,(ctl4 & 0x07) ?
1782 LM93_PWM_MAP_LO_FREQ : LM93_PWM_MAP_HI_FREQ) << 4;
1783 /* save user commanded value */
1784 data->pwm_override[nr] = LM93_PWM_FROM_REG(ctl2 >> 4,
1785 (ctl4 & 0x07) ? LM93_PWM_MAP_LO_FREQ :
1786 LM93_PWM_MAP_HI_FREQ);
1787 lm93_write_byte(client,LM93_REG_PWM_CTL(nr,LM93_PWM_CTL2),ctl2);
1788 mutex_unlock(&data->update_lock);
1789 return count;
1790 }
1791
1792 static SENSOR_DEVICE_ATTR(pwm1, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 0);
1793 static SENSOR_DEVICE_ATTR(pwm2, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 1);
1794
1795 static ssize_t show_pwm_enable(struct device *dev,
1796 struct device_attribute *attr, char *buf)
1797 {
1798 int nr = (to_sensor_dev_attr(attr))->index;
1799 struct lm93_data *data = lm93_update_device(dev);
1800 u8 ctl2;
1801 long rc;
1802
1803 ctl2 = data->block9[nr][LM93_PWM_CTL2];
1804 if (ctl2 & 0x01) /* manual override enabled ? */
1805 rc = ((ctl2 & 0xF0) == 0xF0) ? 0 : 1;
1806 else
1807 rc = 2;
1808 return sprintf(buf,"%ld\n",rc);
1809 }
1810
1811 static ssize_t store_pwm_enable(struct device *dev,
1812 struct device_attribute *attr,
1813 const char *buf, size_t count)
1814 {
1815 int nr = (to_sensor_dev_attr(attr))->index;
1816 struct i2c_client *client = to_i2c_client(dev);
1817 struct lm93_data *data = i2c_get_clientdata(client);
1818 u32 val = simple_strtoul(buf, NULL, 10);
1819 u8 ctl2;
1820
1821 mutex_lock(&data->update_lock);
1822 ctl2 = lm93_read_byte(client,LM93_REG_PWM_CTL(nr,LM93_PWM_CTL2));
1823
1824 switch (val) {
1825 case 0:
1826 ctl2 |= 0xF1; /* enable manual override, set PWM to max */
1827 break;
1828 case 1: ctl2 |= 0x01; /* enable manual override */
1829 break;
1830 case 2: ctl2 &= ~0x01; /* disable manual override */
1831 break;
1832 default:
1833 mutex_unlock(&data->update_lock);
1834 return -EINVAL;
1835 }
1836
1837 lm93_write_byte(client,LM93_REG_PWM_CTL(nr,LM93_PWM_CTL2),ctl2);
1838 mutex_unlock(&data->update_lock);
1839 return count;
1840 }
1841
1842 static SENSOR_DEVICE_ATTR(pwm1_enable, S_IWUSR | S_IRUGO,
1843 show_pwm_enable, store_pwm_enable, 0);
1844 static SENSOR_DEVICE_ATTR(pwm2_enable, S_IWUSR | S_IRUGO,
1845 show_pwm_enable, store_pwm_enable, 1);
1846
1847 static ssize_t show_pwm_freq(struct device *dev, struct device_attribute *attr,
1848 char *buf)
1849 {
1850 int nr = (to_sensor_dev_attr(attr))->index;
1851 struct lm93_data *data = lm93_update_device(dev);
1852 u8 ctl4;
1853
1854 ctl4 = data->block9[nr][LM93_PWM_CTL4];
1855 return sprintf(buf,"%d\n",LM93_PWM_FREQ_FROM_REG(ctl4));
1856 }
1857
1858 /* helper function - must grab data->update_lock before calling
1859 pwm is 0-1, indicating pwm1-pwm2
1860 this disables smart tach for all tach channels bound to the given pwm */
1861 static void lm93_disable_fan_smart_tach(struct i2c_client *client,
1862 struct lm93_data *data, int pwm)
1863 {
1864 int mapping = lm93_read_byte(client, LM93_REG_SF_TACH_TO_PWM);
1865 int mask;
1866
1867 /* collapse the mapping into a mask of enable bits */
1868 mapping = (mapping >> pwm) & 0x55;
1869 mask = mapping & 0x01;
1870 mask |= (mapping & 0x04) >> 1;
1871 mask |= (mapping & 0x10) >> 2;
1872 mask |= (mapping & 0x40) >> 3;
1873
1874 /* disable smart tach according to the mask */
1875 data->sfc2 = lm93_read_byte(client, LM93_REG_SFC2);
1876 data->sfc2 &= ~mask;
1877 lm93_write_byte(client, LM93_REG_SFC2, data->sfc2);
1878 }
1879
1880 static ssize_t store_pwm_freq(struct device *dev,
1881 struct device_attribute *attr,
1882 const char *buf, size_t count)
1883 {
1884 int nr = (to_sensor_dev_attr(attr))->index;
1885 struct i2c_client *client = to_i2c_client(dev);
1886 struct lm93_data *data = i2c_get_clientdata(client);
1887 u32 val = simple_strtoul(buf, NULL, 10);
1888 u8 ctl4;
1889
1890 mutex_lock(&data->update_lock);
1891 ctl4 = lm93_read_byte(client,LM93_REG_PWM_CTL(nr,LM93_PWM_CTL4));
1892 ctl4 = (ctl4 & 0xf8) | LM93_PWM_FREQ_TO_REG(val);
1893 data->block9[nr][LM93_PWM_CTL4] = ctl4;
1894 /* ctl4 == 0 -> 22.5KHz -> disable smart tach */
1895 if (!ctl4)
1896 lm93_disable_fan_smart_tach(client, data, nr);
1897 lm93_write_byte(client, LM93_REG_PWM_CTL(nr,LM93_PWM_CTL4), ctl4);
1898 mutex_unlock(&data->update_lock);
1899 return count;
1900 }
1901
1902 static SENSOR_DEVICE_ATTR(pwm1_freq, S_IWUSR | S_IRUGO,
1903 show_pwm_freq, store_pwm_freq, 0);
1904 static SENSOR_DEVICE_ATTR(pwm2_freq, S_IWUSR | S_IRUGO,
1905 show_pwm_freq, store_pwm_freq, 1);
1906
1907 static ssize_t show_pwm_auto_channels(struct device *dev,
1908 struct device_attribute *attr, char *buf)
1909 {
1910 int nr = (to_sensor_dev_attr(attr))->index;
1911 struct lm93_data *data = lm93_update_device(dev);
1912 return sprintf(buf,"%d\n",data->block9[nr][LM93_PWM_CTL1]);
1913 }
1914
1915 static ssize_t store_pwm_auto_channels(struct device *dev,
1916 struct device_attribute *attr,
1917 const char *buf, size_t count)
1918 {
1919 int nr = (to_sensor_dev_attr(attr))->index;
1920 struct i2c_client *client = to_i2c_client(dev);
1921 struct lm93_data *data = i2c_get_clientdata(client);
1922 u32 val = simple_strtoul(buf, NULL, 10);
1923
1924 mutex_lock(&data->update_lock);
1925 data->block9[nr][LM93_PWM_CTL1] = SENSORS_LIMIT(val, 0, 255);
1926 lm93_write_byte(client, LM93_REG_PWM_CTL(nr,LM93_PWM_CTL1),
1927 data->block9[nr][LM93_PWM_CTL1]);
1928 mutex_unlock(&data->update_lock);
1929 return count;
1930 }
1931
1932 static SENSOR_DEVICE_ATTR(pwm1_auto_channels, S_IWUSR | S_IRUGO,
1933 show_pwm_auto_channels, store_pwm_auto_channels, 0);
1934 static SENSOR_DEVICE_ATTR(pwm2_auto_channels, S_IWUSR | S_IRUGO,
1935 show_pwm_auto_channels, store_pwm_auto_channels, 1);
1936
1937 static ssize_t show_pwm_auto_spinup_min(struct device *dev,
1938 struct device_attribute *attr,char *buf)
1939 {
1940 int nr = (to_sensor_dev_attr(attr))->index;
1941 struct lm93_data *data = lm93_update_device(dev);
1942 u8 ctl3, ctl4;
1943
1944 ctl3 = data->block9[nr][LM93_PWM_CTL3];
1945 ctl4 = data->block9[nr][LM93_PWM_CTL4];
1946 return sprintf(buf,"%d\n",
1947 LM93_PWM_FROM_REG(ctl3 & 0x0f, (ctl4 & 0x07) ?
1948 LM93_PWM_MAP_LO_FREQ : LM93_PWM_MAP_HI_FREQ));
1949 }
1950
1951 static ssize_t store_pwm_auto_spinup_min(struct device *dev,
1952 struct device_attribute *attr,
1953 const char *buf, size_t count)
1954 {
1955 int nr = (to_sensor_dev_attr(attr))->index;
1956 struct i2c_client *client = to_i2c_client(dev);
1957 struct lm93_data *data = i2c_get_clientdata(client);
1958 u32 val = simple_strtoul(buf, NULL, 10);
1959 u8 ctl3, ctl4;
1960
1961 mutex_lock(&data->update_lock);
1962 ctl3 = lm93_read_byte(client,LM93_REG_PWM_CTL(nr, LM93_PWM_CTL3));
1963 ctl4 = lm93_read_byte(client,LM93_REG_PWM_CTL(nr, LM93_PWM_CTL4));
1964 ctl3 = (ctl3 & 0xf0) | LM93_PWM_TO_REG(val, (ctl4 & 0x07) ?
1965 LM93_PWM_MAP_LO_FREQ :
1966 LM93_PWM_MAP_HI_FREQ);
1967 data->block9[nr][LM93_PWM_CTL3] = ctl3;
1968 lm93_write_byte(client,LM93_REG_PWM_CTL(nr, LM93_PWM_CTL3), ctl3);
1969 mutex_unlock(&data->update_lock);
1970 return count;
1971 }
1972
1973 static SENSOR_DEVICE_ATTR(pwm1_auto_spinup_min, S_IWUSR | S_IRUGO,
1974 show_pwm_auto_spinup_min,
1975 store_pwm_auto_spinup_min, 0);
1976 static SENSOR_DEVICE_ATTR(pwm2_auto_spinup_min, S_IWUSR | S_IRUGO,
1977 show_pwm_auto_spinup_min,
1978 store_pwm_auto_spinup_min, 1);
1979
1980 static ssize_t show_pwm_auto_spinup_time(struct device *dev,
1981 struct device_attribute *attr, char *buf)
1982 {
1983 int nr = (to_sensor_dev_attr(attr))->index;
1984 struct lm93_data *data = lm93_update_device(dev);
1985 return sprintf(buf,"%d\n",LM93_SPINUP_TIME_FROM_REG(
1986 data->block9[nr][LM93_PWM_CTL3]));
1987 }
1988
1989 static ssize_t store_pwm_auto_spinup_time(struct device *dev,
1990 struct device_attribute *attr,
1991 const char *buf, size_t count)
1992 {
1993 int nr = (to_sensor_dev_attr(attr))->index;
1994 struct i2c_client *client = to_i2c_client(dev);
1995 struct lm93_data *data = i2c_get_clientdata(client);
1996 u32 val = simple_strtoul(buf, NULL, 10);
1997 u8 ctl3;
1998
1999 mutex_lock(&data->update_lock);
2000 ctl3 = lm93_read_byte(client,LM93_REG_PWM_CTL(nr, LM93_PWM_CTL3));
2001 ctl3 = (ctl3 & 0x1f) | (LM93_SPINUP_TIME_TO_REG(val) << 5 & 0xe0);
2002 data->block9[nr][LM93_PWM_CTL3] = ctl3;
2003 lm93_write_byte(client,LM93_REG_PWM_CTL(nr, LM93_PWM_CTL3), ctl3);
2004 mutex_unlock(&data->update_lock);
2005 return count;
2006 }
2007
2008 static SENSOR_DEVICE_ATTR(pwm1_auto_spinup_time, S_IWUSR | S_IRUGO,
2009 show_pwm_auto_spinup_time,
2010 store_pwm_auto_spinup_time, 0);
2011 static SENSOR_DEVICE_ATTR(pwm2_auto_spinup_time, S_IWUSR | S_IRUGO,
2012 show_pwm_auto_spinup_time,
2013 store_pwm_auto_spinup_time, 1);
2014
2015 static ssize_t show_pwm_auto_prochot_ramp(struct device *dev,
2016 struct device_attribute *attr, char *buf)
2017 {
2018 struct lm93_data *data = lm93_update_device(dev);
2019 return sprintf(buf,"%d\n",
2020 LM93_RAMP_FROM_REG(data->pwm_ramp_ctl >> 4 & 0x0f));
2021 }
2022
2023 static ssize_t store_pwm_auto_prochot_ramp(struct device *dev,
2024 struct device_attribute *attr,
2025 const char *buf, size_t count)
2026 {
2027 struct i2c_client *client = to_i2c_client(dev);
2028 struct lm93_data *data = i2c_get_clientdata(client);
2029 u32 val = simple_strtoul(buf, NULL, 10);
2030 u8 ramp;
2031
2032 mutex_lock(&data->update_lock);
2033 ramp = lm93_read_byte(client, LM93_REG_PWM_RAMP_CTL);
2034 ramp = (ramp & 0x0f) | (LM93_RAMP_TO_REG(val) << 4 & 0xf0);
2035 lm93_write_byte(client, LM93_REG_PWM_RAMP_CTL, ramp);
2036 mutex_unlock(&data->update_lock);
2037 return count;
2038 }
2039
2040 static DEVICE_ATTR(pwm_auto_prochot_ramp, S_IRUGO | S_IWUSR,
2041 show_pwm_auto_prochot_ramp,
2042 store_pwm_auto_prochot_ramp);
2043
2044 static ssize_t show_pwm_auto_vrdhot_ramp(struct device *dev,
2045 struct device_attribute *attr, char *buf)
2046 {
2047 struct lm93_data *data = lm93_update_device(dev);
2048 return sprintf(buf,"%d\n",
2049 LM93_RAMP_FROM_REG(data->pwm_ramp_ctl & 0x0f));
2050 }
2051
2052 static ssize_t store_pwm_auto_vrdhot_ramp(struct device *dev,
2053 struct device_attribute *attr,
2054 const char *buf, size_t count)
2055 {
2056 struct i2c_client *client = to_i2c_client(dev);
2057 struct lm93_data *data = i2c_get_clientdata(client);
2058 u32 val = simple_strtoul(buf, NULL, 10);
2059 u8 ramp;
2060
2061 mutex_lock(&data->update_lock);
2062 ramp = lm93_read_byte(client, LM93_REG_PWM_RAMP_CTL);
2063 ramp = (ramp & 0xf0) | (LM93_RAMP_TO_REG(val) & 0x0f);
2064 lm93_write_byte(client, LM93_REG_PWM_RAMP_CTL, ramp);
2065 mutex_unlock(&data->update_lock);
2066 return 0;
2067 }
2068
2069 static DEVICE_ATTR(pwm_auto_vrdhot_ramp, S_IRUGO | S_IWUSR,
2070 show_pwm_auto_vrdhot_ramp,
2071 store_pwm_auto_vrdhot_ramp);
2072
2073 static ssize_t show_vid(struct device *dev, struct device_attribute *attr,
2074 char *buf)
2075 {
2076 int nr = (to_sensor_dev_attr(attr))->index;
2077 struct lm93_data *data = lm93_update_device(dev);
2078 return sprintf(buf,"%d\n",LM93_VID_FROM_REG(data->vid[nr]));
2079 }
2080
2081 static SENSOR_DEVICE_ATTR(cpu0_vid, S_IRUGO, show_vid, NULL, 0);
2082 static SENSOR_DEVICE_ATTR(cpu1_vid, S_IRUGO, show_vid, NULL, 1);
2083
2084 static ssize_t show_prochot(struct device *dev, struct device_attribute *attr,
2085 char *buf)
2086 {
2087 int nr = (to_sensor_dev_attr(attr))->index;
2088 struct lm93_data *data = lm93_update_device(dev);
2089 return sprintf(buf,"%d\n",data->block4[nr].cur);
2090 }
2091
2092 static SENSOR_DEVICE_ATTR(prochot1, S_IRUGO, show_prochot, NULL, 0);
2093 static SENSOR_DEVICE_ATTR(prochot2, S_IRUGO, show_prochot, NULL, 1);
2094
2095 static ssize_t show_prochot_avg(struct device *dev,
2096 struct device_attribute *attr, char *buf)
2097 {
2098 int nr = (to_sensor_dev_attr(attr))->index;
2099 struct lm93_data *data = lm93_update_device(dev);
2100 return sprintf(buf,"%d\n",data->block4[nr].avg);
2101 }
2102
2103 static SENSOR_DEVICE_ATTR(prochot1_avg, S_IRUGO, show_prochot_avg, NULL, 0);
2104 static SENSOR_DEVICE_ATTR(prochot2_avg, S_IRUGO, show_prochot_avg, NULL, 1);
2105
2106 static ssize_t show_prochot_max(struct device *dev,
2107 struct device_attribute *attr, char *buf)
2108 {
2109 int nr = (to_sensor_dev_attr(attr))->index;
2110 struct lm93_data *data = lm93_update_device(dev);
2111 return sprintf(buf,"%d\n",data->prochot_max[nr]);
2112 }
2113
2114 static ssize_t store_prochot_max(struct device *dev,
2115 struct device_attribute *attr,
2116 const char *buf, size_t count)
2117 {
2118 int nr = (to_sensor_dev_attr(attr))->index;
2119 struct i2c_client *client = to_i2c_client(dev);
2120 struct lm93_data *data = i2c_get_clientdata(client);
2121 u32 val = simple_strtoul(buf, NULL, 10);
2122
2123 mutex_lock(&data->update_lock);
2124 data->prochot_max[nr] = LM93_PROCHOT_TO_REG(val);
2125 lm93_write_byte(client, LM93_REG_PROCHOT_MAX(nr),
2126 data->prochot_max[nr]);
2127 mutex_unlock(&data->update_lock);
2128 return count;
2129 }
2130
2131 static SENSOR_DEVICE_ATTR(prochot1_max, S_IWUSR | S_IRUGO,
2132 show_prochot_max, store_prochot_max, 0);
2133 static SENSOR_DEVICE_ATTR(prochot2_max, S_IWUSR | S_IRUGO,
2134 show_prochot_max, store_prochot_max, 1);
2135
2136 static const u8 prochot_override_mask[] = { 0x80, 0x40 };
2137
2138 static ssize_t show_prochot_override(struct device *dev,
2139 struct device_attribute *attr, char *buf)
2140 {
2141 int nr = (to_sensor_dev_attr(attr))->index;
2142 struct lm93_data *data = lm93_update_device(dev);
2143 return sprintf(buf,"%d\n",
2144 (data->prochot_override & prochot_override_mask[nr]) ? 1 : 0);
2145 }
2146
2147 static ssize_t store_prochot_override(struct device *dev,
2148 struct device_attribute *attr,
2149 const char *buf, size_t count)
2150 {
2151 int nr = (to_sensor_dev_attr(attr))->index;
2152 struct i2c_client *client = to_i2c_client(dev);
2153 struct lm93_data *data = i2c_get_clientdata(client);
2154 u32 val = simple_strtoul(buf, NULL, 10);
2155
2156 mutex_lock(&data->update_lock);
2157 if (val)
2158 data->prochot_override |= prochot_override_mask[nr];
2159 else
2160 data->prochot_override &= (~prochot_override_mask[nr]);
2161 lm93_write_byte(client, LM93_REG_PROCHOT_OVERRIDE,
2162 data->prochot_override);
2163 mutex_unlock(&data->update_lock);
2164 return count;
2165 }
2166
2167 static SENSOR_DEVICE_ATTR(prochot1_override, S_IWUSR | S_IRUGO,
2168 show_prochot_override, store_prochot_override, 0);
2169 static SENSOR_DEVICE_ATTR(prochot2_override, S_IWUSR | S_IRUGO,
2170 show_prochot_override, store_prochot_override, 1);
2171
2172 static ssize_t show_prochot_interval(struct device *dev,
2173 struct device_attribute *attr, char *buf)
2174 {
2175 int nr = (to_sensor_dev_attr(attr))->index;
2176 struct lm93_data *data = lm93_update_device(dev);
2177 u8 tmp;
2178 if (nr==1)
2179 tmp = (data->prochot_interval & 0xf0) >> 4;
2180 else
2181 tmp = data->prochot_interval & 0x0f;
2182 return sprintf(buf,"%d\n",LM93_INTERVAL_FROM_REG(tmp));
2183 }
2184
2185 static ssize_t store_prochot_interval(struct device *dev,
2186 struct device_attribute *attr,
2187 const char *buf, size_t count)
2188 {
2189 int nr = (to_sensor_dev_attr(attr))->index;
2190 struct i2c_client *client = to_i2c_client(dev);
2191 struct lm93_data *data = i2c_get_clientdata(client);
2192 u32 val = simple_strtoul(buf, NULL, 10);
2193 u8 tmp;
2194
2195 mutex_lock(&data->update_lock);
2196 tmp = lm93_read_byte(client, LM93_REG_PROCHOT_INTERVAL);
2197 if (nr==1)
2198 tmp = (tmp & 0x0f) | (LM93_INTERVAL_TO_REG(val) << 4);
2199 else
2200 tmp = (tmp & 0xf0) | LM93_INTERVAL_TO_REG(val);
2201 data->prochot_interval = tmp;
2202 lm93_write_byte(client, LM93_REG_PROCHOT_INTERVAL, tmp);
2203 mutex_unlock(&data->update_lock);
2204 return count;
2205 }
2206
2207 static SENSOR_DEVICE_ATTR(prochot1_interval, S_IWUSR | S_IRUGO,
2208 show_prochot_interval, store_prochot_interval, 0);
2209 static SENSOR_DEVICE_ATTR(prochot2_interval, S_IWUSR | S_IRUGO,
2210 show_prochot_interval, store_prochot_interval, 1);
2211
2212 static ssize_t show_prochot_override_duty_cycle(struct device *dev,
2213 struct device_attribute *attr,
2214 char *buf)
2215 {
2216 struct lm93_data *data = lm93_update_device(dev);
2217 return sprintf(buf,"%d\n",data->prochot_override & 0x0f);
2218 }
2219
2220 static ssize_t store_prochot_override_duty_cycle(struct device *dev,
2221 struct device_attribute *attr,
2222 const char *buf, size_t count)
2223 {
2224 struct i2c_client *client = to_i2c_client(dev);
2225 struct lm93_data *data = i2c_get_clientdata(client);
2226 u32 val = simple_strtoul(buf, NULL, 10);
2227
2228 mutex_lock(&data->update_lock);
2229 data->prochot_override = (data->prochot_override & 0xf0) |
2230 SENSORS_LIMIT(val, 0, 15);
2231 lm93_write_byte(client, LM93_REG_PROCHOT_OVERRIDE,
2232 data->prochot_override);
2233 mutex_unlock(&data->update_lock);
2234 return count;
2235 }
2236
2237 static DEVICE_ATTR(prochot_override_duty_cycle, S_IRUGO | S_IWUSR,
2238 show_prochot_override_duty_cycle,
2239 store_prochot_override_duty_cycle);
2240
2241 static ssize_t show_prochot_short(struct device *dev,
2242 struct device_attribute *attr, char *buf)
2243 {
2244 struct lm93_data *data = lm93_update_device(dev);
2245 return sprintf(buf,"%d\n",(data->config & 0x10) ? 1 : 0);
2246 }
2247
2248 static ssize_t store_prochot_short(struct device *dev,
2249 struct device_attribute *attr,
2250 const char *buf, size_t count)
2251 {
2252 struct i2c_client *client = to_i2c_client(dev);
2253 struct lm93_data *data = i2c_get_clientdata(client);
2254 u32 val = simple_strtoul(buf, NULL, 10);
2255
2256 mutex_lock(&data->update_lock);
2257 if (val)
2258 data->config |= 0x10;
2259 else
2260 data->config &= ~0x10;
2261 lm93_write_byte(client, LM93_REG_CONFIG, data->config);
2262 mutex_unlock(&data->update_lock);
2263 return count;
2264 }
2265
2266 static DEVICE_ATTR(prochot_short, S_IRUGO | S_IWUSR,
2267 show_prochot_short, store_prochot_short);
2268
2269 static ssize_t show_vrdhot(struct device *dev, struct device_attribute *attr,
2270 char *buf)
2271 {
2272 int nr = (to_sensor_dev_attr(attr))->index;
2273 struct lm93_data *data = lm93_update_device(dev);
2274 return sprintf(buf,"%d\n",
2275 data->block1.host_status_1 & (1 << (nr+4)) ? 1 : 0);
2276 }
2277
2278 static SENSOR_DEVICE_ATTR(vrdhot1, S_IRUGO, show_vrdhot, NULL, 0);
2279 static SENSOR_DEVICE_ATTR(vrdhot2, S_IRUGO, show_vrdhot, NULL, 1);
2280
2281 static ssize_t show_gpio(struct device *dev, struct device_attribute *attr,
2282 char *buf)
2283 {
2284 struct lm93_data *data = lm93_update_device(dev);
2285 return sprintf(buf,"%d\n",LM93_GPI_FROM_REG(data->gpi));
2286 }
2287
2288 static DEVICE_ATTR(gpio, S_IRUGO, show_gpio, NULL);
2289
2290 static ssize_t show_alarms(struct device *dev, struct device_attribute *attr,
2291 char *buf)
2292 {
2293 struct lm93_data *data = lm93_update_device(dev);
2294 return sprintf(buf,"%d\n",LM93_ALARMS_FROM_REG(data->block1));
2295 }
2296
2297 static DEVICE_ATTR(alarms, S_IRUGO, show_alarms, NULL);
2298
2299 static struct attribute *lm93_attrs[] = {
2300 &sensor_dev_attr_in1_input.dev_attr.attr,
2301 &sensor_dev_attr_in2_input.dev_attr.attr,
2302 &sensor_dev_attr_in3_input.dev_attr.attr,
2303 &sensor_dev_attr_in4_input.dev_attr.attr,
2304 &sensor_dev_attr_in5_input.dev_attr.attr,
2305 &sensor_dev_attr_in6_input.dev_attr.attr,
2306 &sensor_dev_attr_in7_input.dev_attr.attr,
2307 &sensor_dev_attr_in8_input.dev_attr.attr,
2308 &sensor_dev_attr_in9_input.dev_attr.attr,
2309 &sensor_dev_attr_in10_input.dev_attr.attr,
2310 &sensor_dev_attr_in11_input.dev_attr.attr,
2311 &sensor_dev_attr_in12_input.dev_attr.attr,
2312 &sensor_dev_attr_in13_input.dev_attr.attr,
2313 &sensor_dev_attr_in14_input.dev_attr.attr,
2314 &sensor_dev_attr_in15_input.dev_attr.attr,
2315 &sensor_dev_attr_in16_input.dev_attr.attr,
2316 &sensor_dev_attr_in1_min.dev_attr.attr,
2317 &sensor_dev_attr_in2_min.dev_attr.attr,
2318 &sensor_dev_attr_in3_min.dev_attr.attr,
2319 &sensor_dev_attr_in4_min.dev_attr.attr,
2320 &sensor_dev_attr_in5_min.dev_attr.attr,
2321 &sensor_dev_attr_in6_min.dev_attr.attr,
2322 &sensor_dev_attr_in7_min.dev_attr.attr,
2323 &sensor_dev_attr_in8_min.dev_attr.attr,
2324 &sensor_dev_attr_in9_min.dev_attr.attr,
2325 &sensor_dev_attr_in10_min.dev_attr.attr,
2326 &sensor_dev_attr_in11_min.dev_attr.attr,
2327 &sensor_dev_attr_in12_min.dev_attr.attr,
2328 &sensor_dev_attr_in13_min.dev_attr.attr,
2329 &sensor_dev_attr_in14_min.dev_attr.attr,
2330 &sensor_dev_attr_in15_min.dev_attr.attr,
2331 &sensor_dev_attr_in16_min.dev_attr.attr,
2332 &sensor_dev_attr_in1_max.dev_attr.attr,
2333 &sensor_dev_attr_in2_max.dev_attr.attr,
2334 &sensor_dev_attr_in3_max.dev_attr.attr,
2335 &sensor_dev_attr_in4_max.dev_attr.attr,
2336 &sensor_dev_attr_in5_max.dev_attr.attr,
2337 &sensor_dev_attr_in6_max.dev_attr.attr,
2338 &sensor_dev_attr_in7_max.dev_attr.attr,
2339 &sensor_dev_attr_in8_max.dev_attr.attr,
2340 &sensor_dev_attr_in9_max.dev_attr.attr,
2341 &sensor_dev_attr_in10_max.dev_attr.attr,
2342 &sensor_dev_attr_in11_max.dev_attr.attr,
2343 &sensor_dev_attr_in12_max.dev_attr.attr,
2344 &sensor_dev_attr_in13_max.dev_attr.attr,
2345 &sensor_dev_attr_in14_max.dev_attr.attr,
2346 &sensor_dev_attr_in15_max.dev_attr.attr,
2347 &sensor_dev_attr_in16_max.dev_attr.attr,
2348 &sensor_dev_attr_temp1_input.dev_attr.attr,
2349 &sensor_dev_attr_temp2_input.dev_attr.attr,
2350 &sensor_dev_attr_temp3_input.dev_attr.attr,
2351 &sensor_dev_attr_temp1_min.dev_attr.attr,
2352 &sensor_dev_attr_temp2_min.dev_attr.attr,
2353 &sensor_dev_attr_temp3_min.dev_attr.attr,
2354 &sensor_dev_attr_temp1_max.dev_attr.attr,
2355 &sensor_dev_attr_temp2_max.dev_attr.attr,
2356 &sensor_dev_attr_temp3_max.dev_attr.attr,
2357 &sensor_dev_attr_temp1_auto_base.dev_attr.attr,
2358 &sensor_dev_attr_temp2_auto_base.dev_attr.attr,
2359 &sensor_dev_attr_temp3_auto_base.dev_attr.attr,
2360 &sensor_dev_attr_temp1_auto_boost.dev_attr.attr,
2361 &sensor_dev_attr_temp2_auto_boost.dev_attr.attr,
2362 &sensor_dev_attr_temp3_auto_boost.dev_attr.attr,
2363 &sensor_dev_attr_temp1_auto_boost_hyst.dev_attr.attr,
2364 &sensor_dev_attr_temp2_auto_boost_hyst.dev_attr.attr,
2365 &sensor_dev_attr_temp3_auto_boost_hyst.dev_attr.attr,
2366 &sensor_dev_attr_temp1_auto_offset1.dev_attr.attr,
2367 &sensor_dev_attr_temp1_auto_offset2.dev_attr.attr,
2368 &sensor_dev_attr_temp1_auto_offset3.dev_attr.attr,
2369 &sensor_dev_attr_temp1_auto_offset4.dev_attr.attr,
2370 &sensor_dev_attr_temp1_auto_offset5.dev_attr.attr,
2371 &sensor_dev_attr_temp1_auto_offset6.dev_attr.attr,
2372 &sensor_dev_attr_temp1_auto_offset7.dev_attr.attr,
2373 &sensor_dev_attr_temp1_auto_offset8.dev_attr.attr,
2374 &sensor_dev_attr_temp1_auto_offset9.dev_attr.attr,
2375 &sensor_dev_attr_temp1_auto_offset10.dev_attr.attr,
2376 &sensor_dev_attr_temp1_auto_offset11.dev_attr.attr,
2377 &sensor_dev_attr_temp1_auto_offset12.dev_attr.attr,
2378 &sensor_dev_attr_temp2_auto_offset1.dev_attr.attr,
2379 &sensor_dev_attr_temp2_auto_offset2.dev_attr.attr,
2380 &sensor_dev_attr_temp2_auto_offset3.dev_attr.attr,
2381 &sensor_dev_attr_temp2_auto_offset4.dev_attr.attr,
2382 &sensor_dev_attr_temp2_auto_offset5.dev_attr.attr,
2383 &sensor_dev_attr_temp2_auto_offset6.dev_attr.attr,
2384 &sensor_dev_attr_temp2_auto_offset7.dev_attr.attr,
2385 &sensor_dev_attr_temp2_auto_offset8.dev_attr.attr,
2386 &sensor_dev_attr_temp2_auto_offset9.dev_attr.attr,
2387 &sensor_dev_attr_temp2_auto_offset10.dev_attr.attr,
2388 &sensor_dev_attr_temp2_auto_offset11.dev_attr.attr,
2389 &sensor_dev_attr_temp2_auto_offset12.dev_attr.attr,
2390 &sensor_dev_attr_temp3_auto_offset1.dev_attr.attr,
2391 &sensor_dev_attr_temp3_auto_offset2.dev_attr.attr,
2392 &sensor_dev_attr_temp3_auto_offset3.dev_attr.attr,
2393 &sensor_dev_attr_temp3_auto_offset4.dev_attr.attr,
2394 &sensor_dev_attr_temp3_auto_offset5.dev_attr.attr,
2395 &sensor_dev_attr_temp3_auto_offset6.dev_attr.attr,
2396 &sensor_dev_attr_temp3_auto_offset7.dev_attr.attr,
2397 &sensor_dev_attr_temp3_auto_offset8.dev_attr.attr,
2398 &sensor_dev_attr_temp3_auto_offset9.dev_attr.attr,
2399 &sensor_dev_attr_temp3_auto_offset10.dev_attr.attr,
2400 &sensor_dev_attr_temp3_auto_offset11.dev_attr.attr,
2401 &sensor_dev_attr_temp3_auto_offset12.dev_attr.attr,
2402 &sensor_dev_attr_temp1_auto_pwm_min.dev_attr.attr,
2403 &sensor_dev_attr_temp2_auto_pwm_min.dev_attr.attr,
2404 &sensor_dev_attr_temp3_auto_pwm_min.dev_attr.attr,
2405 &sensor_dev_attr_temp1_auto_offset_hyst.dev_attr.attr,
2406 &sensor_dev_attr_temp2_auto_offset_hyst.dev_attr.attr,
2407 &sensor_dev_attr_temp3_auto_offset_hyst.dev_attr.attr,
2408 &sensor_dev_attr_fan1_input.dev_attr.attr,
2409 &sensor_dev_attr_fan2_input.dev_attr.attr,
2410 &sensor_dev_attr_fan3_input.dev_attr.attr,
2411 &sensor_dev_attr_fan4_input.dev_attr.attr,
2412 &sensor_dev_attr_fan1_min.dev_attr.attr,
2413 &sensor_dev_attr_fan2_min.dev_attr.attr,
2414 &sensor_dev_attr_fan3_min.dev_attr.attr,
2415 &sensor_dev_attr_fan4_min.dev_attr.attr,
2416 &sensor_dev_attr_fan1_smart_tach.dev_attr.attr,
2417 &sensor_dev_attr_fan2_smart_tach.dev_attr.attr,
2418 &sensor_dev_attr_fan3_smart_tach.dev_attr.attr,
2419 &sensor_dev_attr_fan4_smart_tach.dev_attr.attr,
2420 &sensor_dev_attr_pwm1.dev_attr.attr,
2421 &sensor_dev_attr_pwm2.dev_attr.attr,
2422 &sensor_dev_attr_pwm1_enable.dev_attr.attr,
2423 &sensor_dev_attr_pwm2_enable.dev_attr.attr,
2424 &sensor_dev_attr_pwm1_freq.dev_attr.attr,
2425 &sensor_dev_attr_pwm2_freq.dev_attr.attr,
2426 &sensor_dev_attr_pwm1_auto_channels.dev_attr.attr,
2427 &sensor_dev_attr_pwm2_auto_channels.dev_attr.attr,
2428 &sensor_dev_attr_pwm1_auto_spinup_min.dev_attr.attr,
2429 &sensor_dev_attr_pwm2_auto_spinup_min.dev_attr.attr,
2430 &sensor_dev_attr_pwm1_auto_spinup_time.dev_attr.attr,
2431 &sensor_dev_attr_pwm2_auto_spinup_time.dev_attr.attr,
2432 &dev_attr_pwm_auto_prochot_ramp.attr,
2433 &dev_attr_pwm_auto_vrdhot_ramp.attr,
2434 &sensor_dev_attr_cpu0_vid.dev_attr.attr,
2435 &sensor_dev_attr_cpu1_vid.dev_attr.attr,
2436 &sensor_dev_attr_prochot1.dev_attr.attr,
2437 &sensor_dev_attr_prochot2.dev_attr.attr,
2438 &sensor_dev_attr_prochot1_avg.dev_attr.attr,
2439 &sensor_dev_attr_prochot2_avg.dev_attr.attr,
2440 &sensor_dev_attr_prochot1_max.dev_attr.attr,
2441 &sensor_dev_attr_prochot2_max.dev_attr.attr,
2442 &sensor_dev_attr_prochot1_override.dev_attr.attr,
2443 &sensor_dev_attr_prochot2_override.dev_attr.attr,
2444 &sensor_dev_attr_prochot1_interval.dev_attr.attr,
2445 &sensor_dev_attr_prochot2_interval.dev_attr.attr,
2446 &dev_attr_prochot_override_duty_cycle.attr,
2447 &dev_attr_prochot_short.attr,
2448 &sensor_dev_attr_vrdhot1.dev_attr.attr,
2449 &sensor_dev_attr_vrdhot2.dev_attr.attr,
2450 &dev_attr_gpio.attr,
2451 &dev_attr_alarms.attr,
2452 NULL
2453 };
2454
2455 static struct attribute_group lm93_attr_grp = {
2456 .attrs = lm93_attrs,
2457 };
2458
2459 static void lm93_init_client(struct i2c_client *client)
2460 {
2461 int i;
2462 u8 reg;
2463
2464 /* configure VID pin input thresholds */
2465 reg = lm93_read_byte(client, LM93_REG_GPI_VID_CTL);
2466 lm93_write_byte(client, LM93_REG_GPI_VID_CTL,
2467 reg | (vid_agtl ? 0x03 : 0x00));
2468
2469 if (init) {
2470 /* enable #ALERT pin */
2471 reg = lm93_read_byte(client, LM93_REG_CONFIG);
2472 lm93_write_byte(client, LM93_REG_CONFIG, reg | 0x08);
2473
2474 /* enable ASF mode for BMC status registers */
2475 reg = lm93_read_byte(client, LM93_REG_STATUS_CONTROL);
2476 lm93_write_byte(client, LM93_REG_STATUS_CONTROL, reg | 0x02);
2477
2478 /* set sleep state to S0 */
2479 lm93_write_byte(client, LM93_REG_SLEEP_CONTROL, 0);
2480
2481 /* unmask #VRDHOT and dynamic VCCP (if nec) error events */
2482 reg = lm93_read_byte(client, LM93_REG_MISC_ERR_MASK);
2483 reg &= ~0x03;
2484 reg &= ~(vccp_limit_type[0] ? 0x10 : 0);
2485 reg &= ~(vccp_limit_type[1] ? 0x20 : 0);
2486 lm93_write_byte(client, LM93_REG_MISC_ERR_MASK, reg);
2487 }
2488
2489 /* start monitoring */
2490 reg = lm93_read_byte(client, LM93_REG_CONFIG);
2491 lm93_write_byte(client, LM93_REG_CONFIG, reg | 0x01);
2492
2493 /* spin until ready */
2494 for (i=0; i<20; i++) {
2495 msleep(10);
2496 if ((lm93_read_byte(client, LM93_REG_CONFIG) & 0x80) == 0x80)
2497 return;
2498 }
2499
2500 dev_warn(&client->dev,"timed out waiting for sensor "
2501 "chip to signal ready!\n");
2502 }
2503
2504 static int lm93_detect(struct i2c_adapter *adapter, int address, int kind)
2505 {
2506 struct lm93_data *data;
2507 struct i2c_client *client;
2508
2509 int err = -ENODEV, func;
2510 void (*update)(struct lm93_data *, struct i2c_client *);
2511
2512 /* choose update routine based on bus capabilities */
2513 func = i2c_get_functionality(adapter);
2514 if ( ((LM93_SMBUS_FUNC_FULL & func) == LM93_SMBUS_FUNC_FULL) &&
2515 (!disable_block) ) {
2516 dev_dbg(&adapter->dev,"using SMBus block data transactions\n");
2517 update = lm93_update_client_full;
2518 } else if ((LM93_SMBUS_FUNC_MIN & func) == LM93_SMBUS_FUNC_MIN) {
2519 dev_dbg(&adapter->dev,"disabled SMBus block data "
2520 "transactions\n");
2521 update = lm93_update_client_min;
2522 } else {
2523 dev_dbg(&adapter->dev,"detect failed, "
2524 "smbus byte and/or word data not supported!\n");
2525 goto err_out;
2526 }
2527
2528 /* OK. For now, we presume we have a valid client. We now create the
2529 client structure, even though we cannot fill it completely yet.
2530 But it allows us to access lm78_{read,write}_value. */
2531
2532 if ( !(data = kzalloc(sizeof(struct lm93_data), GFP_KERNEL))) {
2533 dev_dbg(&adapter->dev,"out of memory!\n");
2534 err = -ENOMEM;
2535 goto err_out;
2536 }
2537
2538 client = &data->client;
2539 i2c_set_clientdata(client, data);
2540 client->addr = address;
2541 client->adapter = adapter;
2542 client->driver = &lm93_driver;
2543
2544 /* detection */
2545 if (kind < 0) {
2546 int mfr = lm93_read_byte(client, LM93_REG_MFR_ID);
2547
2548 if (mfr != 0x01) {
2549 dev_dbg(&adapter->dev,"detect failed, "
2550 "bad manufacturer id 0x%02x!\n", mfr);
2551 goto err_free;
2552 }
2553 }
2554
2555 if (kind <= 0) {
2556 int ver = lm93_read_byte(client, LM93_REG_VER);
2557
2558 if ((ver == LM93_MFR_ID) || (ver == LM93_MFR_ID_PROTOTYPE)) {
2559 kind = lm93;
2560 } else {
2561 dev_dbg(&adapter->dev,"detect failed, "
2562 "bad version id 0x%02x!\n", ver);
2563 if (kind == 0)
2564 dev_dbg(&adapter->dev,
2565 "(ignored 'force' parameter)\n");
2566 goto err_free;
2567 }
2568 }
2569
2570 /* fill in remaining client fields */
2571 strlcpy(client->name, "lm93", I2C_NAME_SIZE);
2572 dev_dbg(&adapter->dev,"loading %s at %d,0x%02x\n",
2573 client->name, i2c_adapter_id(client->adapter),
2574 client->addr);
2575
2576 /* housekeeping */
2577 data->valid = 0;
2578 data->update = update;
2579 mutex_init(&data->update_lock);
2580
2581 /* tell the I2C layer a new client has arrived */
2582 if ((err = i2c_attach_client(client)))
2583 goto err_free;
2584
2585 /* initialize the chip */
2586 lm93_init_client(client);
2587
2588 err = sysfs_create_group(&client->dev.kobj, &lm93_attr_grp);
2589 if (err)
2590 goto err_detach;
2591
2592 /* Register hwmon driver class */
2593 data->hwmon_dev = hwmon_device_register(&client->dev);
2594 if ( !IS_ERR(data->hwmon_dev))
2595 return 0;
2596
2597 err = PTR_ERR(data->hwmon_dev);
2598 dev_err(&client->dev, "error registering hwmon device.\n");
2599 sysfs_remove_group(&client->dev.kobj, &lm93_attr_grp);
2600 err_detach:
2601 i2c_detach_client(client);
2602 err_free:
2603 kfree(data);
2604 err_out:
2605 return err;
2606 }
2607
2608 /* This function is called when:
2609 * lm93_driver is inserted (when this module is loaded), for each
2610 available adapter
2611 * when a new adapter is inserted (and lm93_driver is still present) */
2612 static int lm93_attach_adapter(struct i2c_adapter *adapter)
2613 {
2614 return i2c_probe(adapter, &addr_data, lm93_detect);
2615 }
2616
2617 static int lm93_detach_client(struct i2c_client *client)
2618 {
2619 struct lm93_data *data = i2c_get_clientdata(client);
2620 int err = 0;
2621
2622 hwmon_device_unregister(data->hwmon_dev);
2623 sysfs_remove_group(&client->dev.kobj, &lm93_attr_grp);
2624
2625 err = i2c_detach_client(client);
2626 if (!err)
2627 kfree(data);
2628 return err;
2629 }
2630
2631 static struct i2c_driver lm93_driver = {
2632 .driver = {
2633 .name = "lm93",
2634 },
2635 .attach_adapter = lm93_attach_adapter,
2636 .detach_client = lm93_detach_client,
2637 };
2638
2639 static int __init lm93_init(void)
2640 {
2641 return i2c_add_driver(&lm93_driver);
2642 }
2643
2644 static void __exit lm93_exit(void)
2645 {
2646 i2c_del_driver(&lm93_driver);
2647 }
2648
2649 MODULE_AUTHOR("Mark M. Hoffman <mhoffman@lightlink.com>, "
2650 "Hans J. Koch <hjk@linutronix.de");
2651 MODULE_DESCRIPTION("LM93 driver");
2652 MODULE_LICENSE("GPL");
2653
2654 module_init(lm93_init);
2655 module_exit(lm93_exit);
linux 2.6 git repository for openrd