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