Context Navigation

lm93.c @ 4658

Revision 4658, 64.4 KB (checked in by khali, 6 years ago)
Fix an array overrun in lm93. Original patch by Hans J. Koch, backported from Linux 2.6.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`

Line
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	This program is free software; you can redistribute it and/or modify
18	it under the terms of the GNU General Public License as published by
19	the Free Software Foundation; either version 2 of the License, or
20	(at your option) any later version.
21
22	This program is distributed in the hope that it will be useful,
23	but WITHOUT ANY WARRANTY; without even the implied warranty of
24	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
25	GNU General Public License for more details.
26
27	You should have received a copy of the GNU General Public License
28	along with this program; if not, write to the Free Software
29	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
30	*/
31
32	#define DEBUG 1
33
34	#include <linux/module.h>
35	#include <linux/slab.h>
36	#include <linux/ioport.h>
37	#include <linux/i2c.h>
38	#include <linux/i2c-proc.h>
39	#include <linux/init.h>
40	#include <linux/delay.h>
41	#include <asm/io.h>
42	#include <asm/bitops.h>
43	#include "version.h"
44	#include "sensors_vid.h"
45	#include "lm93.h"
46
47	#ifndef I2C_DRIVERID_LM93
48	#define I2C_DRIVERID_LM93 1049
49	#endif
50
51	/* I2C addresses to scan */
52	static unsigned short normal_i2c[] = { SENSORS_I2C_END };
53	static unsigned short normal_i2c_range[] = { 0x2c, 0x2e, SENSORS_I2C_END };
54
55	/* ISA addresses to scan (none) */
56	static unsigned int normal_isa[] = { SENSORS_ISA_END };
57	static unsigned int normal_isa_range[] = { SENSORS_ISA_END };
58
59	/* module parameters */
60	SENSORS_INSMOD_1(lm93);
61
62	static int disable_block /* = 0 */ ;
63	MODULE_PARM(disable_block, "i");
64	MODULE_PARM_DESC(disable_block,
65	"Set to non-zero to disable SMBus block data transactions.");
66
67	static int init = 1;
68	MODULE_PARM(init, "i");
69	MODULE_PARM_DESC(init, "Set to zero to bypass most chip initialization");
70
71	static int vccp_limit_type[2] /* = {0,0} */ ;
72	MODULE_PARM(vccp_limit_type, "2-2i");
73	MODULE_PARM_DESC(vccp_limit_type, "Configures in7 and in8 limit modes");
74
75	static int vid_agtl = 0;
76	MODULE_PARM(vid_agtl, "i");
77	MODULE_PARM_DESC(vid_agtl, "Configures VID pin input thresholds");
78
79	/* -- SENSORS SYSCTL START -- */
80	/* volts * 100 */
81	#define LM93_SYSCTL_IN1 1001
82	#define LM93_SYSCTL_IN2 1002
83	#define LM93_SYSCTL_IN3 1003
84	#define LM93_SYSCTL_IN4 1004
85	#define LM93_SYSCTL_IN5 1005
86	#define LM93_SYSCTL_IN6 1006
87	#define LM93_SYSCTL_IN7 1007
88	#define LM93_SYSCTL_IN8 1008
89	#define LM93_SYSCTL_IN9 1009
90	#define LM93_SYSCTL_IN10 1010
91	#define LM93_SYSCTL_IN11 1011
92	#define LM93_SYSCTL_IN12 1012
93	#define LM93_SYSCTL_IN13 1013
94	#define LM93_SYSCTL_IN14 1014
95	#define LM93_SYSCTL_IN15 1015
96	#define LM93_SYSCTL_IN16 1016
97
98	/* degrees Celsius * 10 */
99	#define LM93_SYSCTL_TEMP1 1101
100	#define LM93_SYSCTL_TEMP2 1102
101	#define LM93_SYSCTL_TEMP3 1103
102
103	#define LM93_SYSCTL_TEMP1_AUTO_BASE 1111
104	#define LM93_SYSCTL_TEMP2_AUTO_BASE 1112
105	#define LM93_SYSCTL_TEMP3_AUTO_BASE 1113
106
107	#define LM93_SYSCTL_TEMP1_AUTO_OFFSETS 1121
108	#define LM93_SYSCTL_TEMP2_AUTO_OFFSETS 1122
109	#define LM93_SYSCTL_TEMP3_AUTO_OFFSETS 1123
110
111	#define LM93_SYSCTL_TEMP1_AUTO_BOOST 1131
112	#define LM93_SYSCTL_TEMP2_AUTO_BOOST 1132
113	#define LM93_SYSCTL_TEMP3_AUTO_BOOST 1133
114
115	#define LM93_SYSCTL_TEMP1_AUTO_BOOST_HYST 1141
116	#define LM93_SYSCTL_TEMP2_AUTO_BOOST_HYST 1142
117	#define LM93_SYSCTL_TEMP3_AUTO_BOOST_HYST 1143
118
119	/* 0 => off, 255 => 100% */
120	#define LM93_SYSCTL_TEMP1_AUTO_PWM_MIN 1151
121	#define LM93_SYSCTL_TEMP2_AUTO_PWM_MIN 1152
122	#define LM93_SYSCTL_TEMP3_AUTO_PWM_MIN 1153
123
124	/* degrees Celsius * 10 */
125	#define LM93_SYSCTL_TEMP1_AUTO_OFFSET_HYST 1161
126	#define LM93_SYSCTL_TEMP2_AUTO_OFFSET_HYST 1162
127	#define LM93_SYSCTL_TEMP3_AUTO_OFFSET_HYST 1163
128
129	/* rotations/minute */
130	#define LM93_SYSCTL_FAN1 1201
131	#define LM93_SYSCTL_FAN2 1202
132	#define LM93_SYSCTL_FAN3 1203
133	#define LM93_SYSCTL_FAN4 1204
134
135	/* 1-2 => enable smart tach mode associated with this pwm #, or disable */
136	#define LM93_SYSCTL_FAN1_SMART_TACH 1205
137	#define LM93_SYSCTL_FAN2_SMART_TACH 1206
138	#define LM93_SYSCTL_FAN3_SMART_TACH 1207
139	#define LM93_SYSCTL_FAN4_SMART_TACH 1208
140
141	/* volts * 1000 */
142	#define LM93_SYSCTL_VID1 1301
143	#define LM93_SYSCTL_VID2 1302
144
145	/* 0 => off, 255 => 100% */
146	#define LM93_SYSCTL_PWM1 1401
147	#define LM93_SYSCTL_PWM2 1402
148
149	/* Hz */
150	#define LM93_SYSCTL_PWM1_FREQ 1411
151	#define LM93_SYSCTL_PWM2_FREQ 1412
152
153	/* bitvector */
154	#define LM93_SYSCTL_PWM1_AUTO_CHANNELS 1421
155	#define LM93_SYSCTL_PWM2_AUTO_CHANNELS 1422
156
157	/* Hz */
158	#define LM93_SYSCTL_PWM1_AUTO_SPINUP_MIN 1431
159	#define LM93_SYSCTL_PWM2_AUTO_SPINUP_MIN 1432
160
161	/* seconds */
162	#define LM93_SYSCTL_PWM1_AUTO_SPINUP_TIME 1441
163	#define LM93_SYSCTL_PWM2_AUTO_SPINUP_TIME 1442
164
165	/* seconds */
166	#define LM93_SYSCTL_PWM_AUTO_PROCHOT_RAMP 1451
167	#define LM93_SYSCTL_PWM_AUTO_VRDHOT_RAMP 1452
168
169	/* 0 => 0%, 255 => > 99.6% */
170	#define LM93_SYSCTL_PROCHOT1 1501
171	#define LM93_SYSCTL_PROCHOT2 1502
172
173	/* !0 => enable #PROCHOT logical short */
174	#define LM93_SYSCTL_PROCHOT_SHORT 1503
175
176	/* 2 boolean enable/disable, 3rd value indicates duty cycle */
177	#define LM93_SYSCTL_PROCHOT_OVERRIDE 1504
178
179	/* 2 values, 0-9 */
180	#define LM93_SYSCTL_PROCHOT_INTERVAL 1505
181
182	/* GPIO input (bitmask) */
183	#define LM93_SYSCTL_GPIO 1601
184
185	/* #VRDHOT input (boolean) */
186	#define LM93_SYSCTL_VRDHOT1 1701
187	#define LM93_SYSCTL_VRDHOT2 1702
188
189	/* alarms (bitmask) */
190	#define LM93_SYSCTL_ALARMS 2001
191
192	/* alarm bitmask definitions
193	The LM93 has nearly 64 bits of error status... I've pared that down to
194	what I think is a useful subset in order to fit it into 32 bits.
195
196	Especially note that the #VRD_HOT alarms are missing because we provide
197	that information as values in another /proc file.
198
199	If libsensors is extended to support 64 bit values, this could be revisited.
200	*/
201	#define LM93_ALARM_IN1 0x00000001
202	#define LM93_ALARM_IN2 0x00000002
203	#define LM93_ALARM_IN3 0x00000004
204	#define LM93_ALARM_IN4 0x00000008
205	#define LM93_ALARM_IN5 0x00000010
206	#define LM93_ALARM_IN6 0x00000020
207	#define LM93_ALARM_IN7 0x00000040
208	#define LM93_ALARM_IN8 0x00000080
209	#define LM93_ALARM_IN9 0x00000100
210	#define LM93_ALARM_IN10 0x00000200
211	#define LM93_ALARM_IN11 0x00000400
212	#define LM93_ALARM_IN12 0x00000800
213	#define LM93_ALARM_IN13 0x00001000
214	#define LM93_ALARM_IN14 0x00002000
215	#define LM93_ALARM_IN15 0x00004000
216	#define LM93_ALARM_IN16 0x00008000
217	#define LM93_ALARM_FAN1 0x00010000
218	#define LM93_ALARM_FAN2 0x00020000
219	#define LM93_ALARM_FAN3 0x00040000
220	#define LM93_ALARM_FAN4 0x00080000
221	#define LM93_ALARM_PH1_ERR 0x00100000
222	#define LM93_ALARM_PH2_ERR 0x00200000
223	#define LM93_ALARM_SCSI1_ERR 0x00400000
224	#define LM93_ALARM_SCSI2_ERR 0x00800000
225	#define LM93_ALARM_DVDDP1_ERR 0x01000000
226	#define LM93_ALARM_DVDDP2_ERR 0x02000000
227	#define LM93_ALARM_D1_ERR 0x04000000
228	#define LM93_ALARM_D2_ERR 0x08000000
229	#define LM93_ALARM_TEMP1 0x10000000
230	#define LM93_ALARM_TEMP2 0x20000000
231	#define LM93_ALARM_TEMP3 0x40000000
232
233	/* -- SENSORS SYSCTL END -- */
234
235	/* SMBus capabilities */
236	#define LM93_SMBUS_FUNC_FULL (I2C_FUNC_SMBUS_BYTE_DATA \| \
237	I2C_FUNC_SMBUS_WORD_DATA \| I2C_FUNC_SMBUS_BLOCK_DATA)
238	#define LM93_SMBUS_FUNC_MIN (I2C_FUNC_SMBUS_BYTE_DATA \| \
239	I2C_FUNC_SMBUS_WORD_DATA)
240
241	/* LM93 BLOCK READ COMMANDS */
242	static const struct { u8 cmd; u8 len; } lm93_block_read_cmds[12] = {
243	{ 0xf2, 8 },
244	{ 0xf3, 8 },
245	{ 0xf4, 6 },
246	{ 0xf5, 16 },
247	{ 0xf6, 4 },
248	{ 0xf7, 8 },
249	{ 0xf8, 12 },
250	{ 0xf9, 32 },
251	{ 0xfa, 8 },
252	{ 0xfb, 8 },
253	{ 0xfc, 16 },
254	{ 0xfd, 9 },
255	};
256
257	/* ALARMS: SYSCTL format described further below
258	REG: 64 bits in 8 registers, as immediately below */
259	struct block1_t {
260	u8 host_status_1;
261	u8 host_status_2;
262	u8 host_status_3;
263	u8 host_status_4;
264	u8 p1_prochot_status;
265	u8 p2_prochot_status;
266	u8 gpi_status;
267	u8 fan_status;
268	};
269
270	/* unique ID for each LM93 detected */
271	static int lm93_id = 0;
272
273	/* For each registered client, we need to keep some data in memory. That
274	data is pointed to by client->data. The structure itself is dynamically
275	allocated, at the same time the client itself is allocated. */
276
277	struct lm93_data {
278	struct i2c_client client;
279	int sysctl_id;
280
281	struct semaphore update_lock;
282	unsigned long last_updated; /* In jiffies */
283
284	/* client update function */
285	void (update)(struct lm93_data , struct i2c_client *);
286
287	char valid; /* !=0 if following fields are valid */
288
289	/* register values, arranged by block read groups */
290	struct block1_t block1;
291
292	/* temp1 - temp4: unfiltered readings
293	temp1 - temp2: filtered readings */
294	u8 block2[6];
295
296	/* vin1 - vin16: readings */
297	u8 block3[16];
298
299	/* prochot1 - prochot2: readings */
300	struct { u8 cur; u8 avg; } block4[2];
301
302	/* fan counts 1-4 => 14-bits, LE, left justified */
303	u16 block5[4];
304
305	/* block6 has a lot of data we don't need */
306	struct { u8 min; u8 max; } temp_lim[4];
307
308	/* vin1 - vin16: low and high limits */
309	struct { u8 min; u8 max; } block7[16];
310
311	/* fan count limits 1-4 => same format as block5 */
312	u16 block8[4];
313
314	/* pwm control registers (2 pwms, 4 regs) */
315	u8 block9[2][4];
316
317	/* auto/pwm base temp and offset temp registers */
318	struct { u8 base[4]; u8 offset[12]; } block10;
319
320	/* master config register */
321	u8 config;
322
323	/* VID1 & VID2 => register format, 6-bits, right justified */
324	u8 vid[2];
325
326	/* prochot1 - prochot2: limits */
327	u8 prochot_max[2];
328
329	/* vccp1 & vccp2 (in7 & in8): VID relative limits (register format) */
330	u8 vccp_limits[2];
331
332	/* GPIO input state (register format, i.e. inverted) */
333	u8 gpi;
334
335	/* #PROCHOT override (register format) */
336	u8 prochot_override;
337
338	/* #PROCHOT intervals (register format) */
339	u8 prochot_interval;
340
341	/* Fan Boost Temperatures (register format) */
342	u8 boost[4];
343
344	/* Fan Boost Hysteresis (register format) */
345	u8 boost_hyst[2];
346
347	/* Temperature Zone Min. PWM & Hysteresis (register format) */
348	u8 auto_pwm_min_hyst[2];
349
350	/* #PROCHOT & #VRDHOT PWM Ramp Control */
351	u8 pwm_ramp_ctl;
352
353	/* miscellaneous setup regs */
354	u8 sfc1;
355	u8 sfc2;
356	u8 sf_tach_to_pwm;
357
358	/* The two PWM CTL2 registers can read something other than what was
359	last written for the OVR_DC field (duty cycle override). So, we
360	save the user-commanded value here. */
361	u8 pwm_override[2];
362	};
363
364	#define MAX_RETRIES 5
365
366	static u8 lm93_read_byte(struct i2c_client *client, u8 reg)
367	{
368	int value, i;
369
370	/* retry in case of read errors */
371	for (i=1; i<=MAX_RETRIES; i++) {
372	if ((value = i2c_smbus_read_byte_data(client, reg)) >= 0) {
373	return value;
374	} else {
375	printk(KERN_WARNING "lm93.o: read byte data failed, "
376	"address 0x%02x.\n", reg);
377	mdelay(i + 3);
378	}
379
380	}
381
382	/* <TODO> what to return in case of error? */
383	printk(KERN_ERR "lm93.o: All read byte retries failed!!\n");
384	return 0;
385	}
386
387	static int lm93_write_byte(struct i2c_client *client, u8 reg, u8 value)
388	{
389	int result;
390
391	/* <TODO> how to handle write errors? */
392	result = i2c_smbus_write_byte_data(client, reg, value);
393
394	if (result < 0)
395	printk(KERN_WARNING "lm93.o: write byte data failed, "
396	"0x%02x at address 0x%02x.\n", value, reg);
397
398	return result;
399	}
400
401	static u16 lm93_read_word(struct i2c_client *client, u8 reg)
402	{
403	int value, i;
404
405	/* retry in case of read errors */
406	for (i=1; i<=MAX_RETRIES; i++) {
407	if ((value = i2c_smbus_read_word_data(client, reg)) >= 0) {
408	return value;
409	} else {
410	printk(KERN_WARNING "lm93.o: read word data failed, "
411	"address 0x%02x.\n", reg);
412	mdelay(i + 3);
413	}
414
415	}
416
417	/* <TODO> what to return in case of error? */
418	printk(KERN_ERR "lm93.o: All read word retries failed!!\n");
419	return 0;
420	}
421
422	static int lm93_write_word(struct i2c_client *client, u8 reg, u16 value)
423	{
424	int result;
425
426	/* <TODO> how to handle write errors? */
427	result = i2c_smbus_write_word_data(client, reg, value);
428
429	if (result < 0)
430	printk(KERN_WARNING "lm93.o: write word data failed, "
431	"0x%04x at address 0x%02x.\n", value, reg);
432
433	return result;
434	}
435
436	static u8 lm93_block_buffer[I2C_SMBUS_BLOCK_MAX];
437
438	/*
439	read block data into values, retry if not expected length
440	fbn => index to lm93_block_read_cmds table
441	(Fixed Block Number - section 14.5.2 of LM93 datasheet)
442	*/
443	static void lm93_read_block(struct i2c_client client, u8 fbn, u8 values)
444	{
445	int i, result=0;
446
447	for (i = 1; i <= MAX_RETRIES; i++) {
448	result = i2c_smbus_read_block_data(client,
449	lm93_block_read_cmds[fbn].cmd, lm93_block_buffer);
450
451	if (result == lm93_block_read_cmds[fbn].len) {
452	break;
453	} else {
454	printk(KERN_WARNING "lm93.o: block read data failed, "
455	"command 0x%02x.\n",
456	lm93_block_read_cmds[fbn].cmd);
457	mdelay(i + 3);
458	}
459	}
460
461	if (result == lm93_block_read_cmds[fbn].len) {
462	memcpy(values,lm93_block_buffer,lm93_block_read_cmds[fbn].len);
463	} else {
464	/* <TODO> what to do in case of error? */
465	}
466	}
467
468	static void lm93_update_client(struct i2c_client *client)
469	{
470	struct lm93_data *data = client->data;
471
472	down(&data->update_lock);
473
474	if (time_after(jiffies - data->last_updated, HZ + HZ / 2) \|\|
475	time_before(jiffies, data->last_updated) \|\| !data->valid) {
476
477	data->update(data, client);
478	data->last_updated = jiffies;
479	data->valid = 1;
480	}
481
482	up(&data->update_lock);
483	}
484
485	/* update routine for data that has no corresponding SMBus block data command */
486	static void lm93_update_client_common(struct lm93_data *data,
487	struct i2c_client *client)
488	{
489	int i;
490	u8 *ptr;
491
492	/* temp1 - temp4: limits */
493	for (i = 0; i < 4; i++) {
494	data->temp_lim[i].min =
495	lm93_read_byte(client, LM93_REG_TEMP_MIN(i));
496	data->temp_lim[i].max =
497	lm93_read_byte(client, LM93_REG_TEMP_MAX(i));
498	}
499
500	/* config register */
501	data->config = lm93_read_byte(client, LM93_REG_CONFIG);
502
503	/* vid1 - vid2: values */
504	for (i = 0; i < 2; i++)
505	data->vid[i] = lm93_read_byte(client, LM93_REG_VID(i));
506
507	/* prochot1 - prochot2: limits */
508	for (i = 0; i < 2; i++)
509	data->prochot_max[i] = lm93_read_byte(client,
510	LM93_REG_PROCHOT_MAX(i));
511
512	/* vccp1 - vccp2: VID relative limits */
513	for (i = 0; i < 2; i++)
514	data->vccp_limits[i] = lm93_read_byte(client,
515	LM93_REG_VCCP_LIMIT_OFF(i));
516
517	/* GPIO input state */
518	data->gpi = lm93_read_byte(client, LM93_REG_GPI);
519
520	/* #PROCHOT override state */
521	data->prochot_override = lm93_read_byte(client,
522	LM93_REG_PROCHOT_OVERRIDE);
523
524	/* #PROCHOT intervals */
525	data->prochot_interval = lm93_read_byte(client,
526	LM93_REG_PROCHOT_INTERVAL);
527
528	/* Fan Boost Termperature registers */
529	for (i = 0; i < 4; i++)
530	data->boost[i] = lm93_read_byte(client, LM93_REG_BOOST(i));
531
532	/* Fan Boost Temperature Hyst. registers */
533	data->boost_hyst[0] = lm93_read_byte(client, LM93_REG_BOOST_HYST_12);
534	data->boost_hyst[1] = lm93_read_byte(client, LM93_REG_BOOST_HYST_34);
535
536	/* Temperature Zone Min. PWM & Hysteresis registers */
537	data->auto_pwm_min_hyst[0] =
538	lm93_read_byte(client, LM93_REG_PWM_MIN_HYST_12);
539	data->auto_pwm_min_hyst[1] =
540	lm93_read_byte(client, LM93_REG_PWM_MIN_HYST_34);
541
542	/* #PROCHOT & #VRDHOT PWM Ramp Control register */
543	data->pwm_ramp_ctl = lm93_read_byte(client, LM93_REG_PWM_RAMP_CTL);
544
545	/* misc setup registers */
546	data->sfc1 = lm93_read_byte(client, LM93_REG_SFC1);
547	data->sfc2 = lm93_read_byte(client, LM93_REG_SFC2);
548	data->sf_tach_to_pwm = lm93_read_byte(client,
549	LM93_REG_SF_TACH_TO_PWM);
550
551	/* write back alarm values to clear */
552	for (i = 0, ptr = (u8 *)(&data->block1); i < 8; i++)
553	lm93_write_byte(client, LM93_REG_HOST_ERROR_1 + i, *(ptr + i));
554	}
555
556	/* update routine which uses SMBus block data commands */
557	static void lm93_update_client_full(struct lm93_data *data,
558	struct i2c_client *client)
559	{
560	pr_debug("lm93.o: starting device update (block data enabled)\n");
561
562	/* in1 - in16: values & limits */
563	lm93_read_block(client, 3, (u8 *)(data->block3));
564	lm93_read_block(client, 7, (u8 *)(data->block7));
565
566	/* temp1 - temp4: values */
567	lm93_read_block(client, 2, (u8 *)(data->block2));
568
569	/* prochot1 - prochot2: values */
570	lm93_read_block(client, 4, (u8 *)(data->block4));
571
572	/* fan1 - fan4: values & limits */
573	lm93_read_block(client, 5, (u8 *)(data->block5));
574	lm93_read_block(client, 8, (u8 *)(data->block8));
575
576	/* pmw control registers */
577	lm93_read_block(client, 9, (u8 *)(data->block9));
578
579	/* alarm values */
580	lm93_read_block(client, 1, (u8 *)(&data->block1));
581
582	/* auto/pwm registers */
583	lm93_read_block(client, 10, (u8 *)(&data->block10));
584
585	lm93_update_client_common(data, client);
586	}
587
588	/* update routine which uses SMBus byte/word data commands only */
589	static void lm93_update_client_min(struct lm93_data *data,
590	struct i2c_client *client)
591	{
592	int i,j;
593	u8 *ptr;
594
595	pr_debug("lm93.o: starting device update (block data disabled)\n");
596
597	/* in1 - in16: values & limits */
598	for (i = 0; i < 16; i++) {
599	data->block3[i] =
600	lm93_read_byte(client, LM93_REG_IN(i));
601	data->block7[i].min =
602	lm93_read_byte(client, LM93_REG_IN_MIN(i));
603	data->block7[i].max =
604	lm93_read_byte(client, LM93_REG_IN_MAX(i));
605	}
606
607	/* temp1 - temp4: values */
608	for (i = 0; i < 4; i++) {
609	data->block2[i] =
610	lm93_read_byte(client, LM93_REG_TEMP(i));
611	}
612
613	/* prochot1 - prochot2: values */
614	for (i = 0; i < 2; i++) {
615	data->block4[i].cur =
616	lm93_read_byte(client, LM93_REG_PROCHOT_CUR(i));
617	data->block4[i].avg =
618	lm93_read_byte(client, LM93_REG_PROCHOT_AVG(i));
619	}
620
621	/* fan1 - fan4: values & limits */
622	for (i = 0; i < 4; i++) {
623	data->block5[i] =
624	lm93_read_word(client, LM93_REG_FAN(i));
625	data->block8[i] =
626	lm93_read_word(client, LM93_REG_FAN_MIN(i));
627	}
628
629	/* pwm control registers */
630	for (i = 0; i < 2; i++) {
631	for (j = 0; j < 4; j++) {
632	data->block9[i][j] =
633	lm93_read_byte(client, LM93_REG_PWM_CTL(i,j));
634	}
635	}
636
637	/* alarm values */
638	for (i = 0, ptr = (u8 *)(&data->block1); i < 8; i++) {
639	*(ptr + i) =
640	lm93_read_byte(client, LM93_REG_HOST_ERROR_1 + i);
641	}
642
643	/* auto/pwm (base temp) registers */
644	for (i = 0; i < 4; i++) {
645	data->block10.base[i] =
646	lm93_read_byte(client, LM93_REG_TEMP_BASE(i));
647	}
648
649	/* auto/pwm (offset temp) registers */
650	for (i = 0; i < 12; i++) {
651	data->block10.offset[i] =
652	lm93_read_byte(client, LM93_REG_TEMP_OFFSET(i));
653	}
654
655	lm93_update_client_common(data, client);
656	}
657
658	/* VID: mV
659	REG: 6-bits, right justified, always using Intel VRM/VRD 10 */
660	static int LM93_VID_FROM_REG(u8 reg)
661	{
662	return vid_from_reg((reg & 0x3f), 100);
663	}
664
665	static void lm93_vid(struct i2c_client *client, int operation, int ctl_name,
666	int nrels_mag, long results)
667	{
668	struct lm93_data *data = client->data;
669	int nr = ctl_name - LM93_SYSCTL_VID1;
670
671	if (0 > nr \|\| nr > 1)
672	return; /* ERROR */
673
674	if (operation == SENSORS_PROC_REAL_INFO)
675	*nrels_mag = 3;
676	else if (operation == SENSORS_PROC_REAL_READ) {
677	lm93_update_client(client);
678	results[0] = LM93_VID_FROM_REG(data->vid[nr]);
679	*nrels_mag = 1;
680	}
681	}
682
683	/* min, max, and nominal voltage readings, per channel (mV)*/
684	static const unsigned long lm93_vin_val_min[16] = {
685	0, 0, 0, 0, 0, 0, 0, 0,
686	0, 0, 0, 0, 0, 0, 0, 3000,
687	};
688	static const unsigned long lm93_vin_val_max[16] = {
689	1236, 1236, 1236, 1600, 2000, 2000, 1600, 1600,
690	4400, 6500, 3333, 2625, 1312, 1312, 1236, 3600,
691	};
692	/*
693	static const unsigned long lm93_vin_val_nom[16] = {
694	927, 927, 927, 1200, 1500, 1500, 1200, 1200,
695	3300, 5000, 2500, 1969, 984, 984, 309, 3300,
696	};
697	*/
698
699	/* min, max, and nominal register values, per channel (u8) */
700	static const u8 lm93_vin_reg_min[16] = {
701	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
702	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xae,
703	};
704	static const u8 lm93_vin_reg_max[16] = {
705	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
706	0xff, 0xfa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd1,
707	};
708	/*
709	static const u8 lm93_vin_reg_nom[16] = {
710	0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0,
711	0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0x40, 0xc0,
712	};
713	*/
714
715	/* IN: 1/100 V, limits determined by channel nr
716	REG: scaling determined by channel nr */
717	static u8 LM93_IN_TO_REG(int nr, unsigned val)
718	{
719	/* range limit */
720	const long mV = SENSORS_LIMIT(val * 10,
721	lm93_vin_val_min[nr], lm93_vin_val_max[nr]);
722
723	/* try not to lose too much precision here */
724	const long uV = mV * 1000;
725	const long uV_max = lm93_vin_val_max[nr] * 1000;
726	const long uV_min = lm93_vin_val_min[nr] * 1000;
727
728	/* convert */
729	const long slope = (uV_max - uV_min) /
730	(lm93_vin_reg_max[nr] - lm93_vin_reg_min[nr]);
731	const long intercept = uV_min - slope * lm93_vin_reg_min[nr];
732
733	u8 result = ((uV - intercept + (slope/2)) / slope);
734	result = SENSORS_LIMIT(result,
735	lm93_vin_reg_min[nr], lm93_vin_reg_max[nr]);
736	return result;
737	}
738
739	static unsigned LM93_IN_FROM_REG(int nr, u8 reg)
740	{
741	const long uV_max = lm93_vin_val_max[nr] * 1000;
742	const long uV_min = lm93_vin_val_min[nr] * 1000;
743
744	const long slope = (uV_max - uV_min) /
745	(lm93_vin_reg_max[nr] - lm93_vin_reg_min[nr]);
746	const long intercept = uV_min - slope * lm93_vin_reg_min[nr];
747
748	return (slope * reg + intercept + 5000) / 10000;
749	}
750
751	/* vid in mV , upper == 0 indicates low limit, otherwise upper limit
752	upper also determines which nibble of the register is returned
753	(the other nibble will be 0x0) */
754	static u8 LM93_IN_REL_TO_REG(unsigned val, int upper, int vid)
755	{
756	long uV_offset = vid * 1000 - val * 10000;
757	if (upper) {
758	uV_offset = SENSORS_LIMIT(uV_offset, 12500, 200000);
759	return (u8)((uV_offset / 12500 - 1) << 4);
760	} else {
761	uV_offset = SENSORS_LIMIT(uV_offset, -400000, -25000);
762	return (u8)((uV_offset / -25000 - 1) << 0);
763	}
764	}
765
766	/* vid in mV, upper == 0 indicates low limit, otherwise upper limit */
767	static unsigned LM93_IN_REL_FROM_REG(u8 reg, int upper, int vid)
768	{
769	const long uV_offset = upper ? (((reg >> 4 & 0x0f) + 1) * 12500) :
770	(((reg >> 0 & 0x0f) + 1) * -25000);
771	const long uV_vid = vid * 1000;
772	return (uV_vid + uV_offset + 5000) / 10000;
773	}
774
775	static void lm93_in(struct i2c_client *client, int operation, int ctl_name,
776	int nrels_mag, long results)
777	{
778	struct lm93_data *data = client->data;
779	int nr = ctl_name - LM93_SYSCTL_IN1; /* 0 <= nr <= 15 */
780	int vccp = ctl_name - LM93_SYSCTL_IN7; /* 0 <= vccp <= 1 if relevant */
781
782	if (operation == SENSORS_PROC_REAL_INFO)
783	*nrels_mag = 2;
784	else if (operation == SENSORS_PROC_REAL_READ) {
785
786	lm93_update_client(client);
787
788	/* for limits, check in7 and in8 for VID relative mode */
789	if ((ctl_name==LM93_SYSCTL_IN7 \|\| ctl_name==LM93_SYSCTL_IN8) &&
790	(vccp_limit_type[vccp])) {
791	long vid = LM93_VID_FROM_REG(data->vid[vccp]);
792	results[0] = LM93_IN_REL_FROM_REG(
793	data->vccp_limits[vccp], 0, vid);
794	results[1] = LM93_IN_REL_FROM_REG(
795	data->vccp_limits[vccp], 1, vid);
796
797	/* otherwise, use absolute limits */
798	} else {
799	results[0] = LM93_IN_FROM_REG(nr,
800	data->block7[nr].min);
801	results[1] = LM93_IN_FROM_REG(nr,
802	data->block7[nr].max);
803	}
804
805	results[2] = LM93_IN_FROM_REG(nr, data->block3[nr]);
806	*nrels_mag = 3;
807	} else if (operation == SENSORS_PROC_REAL_WRITE) {
808	down(&data->update_lock);
809
810	/* for limits, check in7 and in8 for VID relative mode */
811	if ((ctl_name==LM93_SYSCTL_IN7 \|\| ctl_name==LM93_SYSCTL_IN8) &&
812	(vccp_limit_type[vccp])) {
813
814	long vid = LM93_VID_FROM_REG(data->vid[vccp]);
815	if (*nrels_mag >= 2) {
816	data->vccp_limits[vccp] =
817	(data->vccp_limits[vccp] & 0x0f) \|
818	LM93_IN_REL_TO_REG(results[1], 1, vid);
819	}
820	if (*nrels_mag >= 1) {
821	data->vccp_limits[vccp] =
822	(data->vccp_limits[vccp] & 0xf0) \|
823	LM93_IN_REL_TO_REG(results[0], 0, vid);
824	lm93_write_byte(client,
825	LM93_REG_VCCP_LIMIT_OFF(vccp),
826	data->vccp_limits[vccp]);
827	}
828
829	/* otherwise, use absolute limits */
830	} else {
831	if (*nrels_mag >= 1) {
832	data->block7[nr].min = LM93_IN_TO_REG(nr,
833	results[0]);
834	lm93_write_byte(client, LM93_REG_IN_MIN(nr),
835	data->block7[nr].min);
836	}
837	if (*nrels_mag >= 2) {
838	data->block7[nr].max = LM93_IN_TO_REG(nr,
839	results[1]);
840	lm93_write_byte(client, LM93_REG_IN_MAX(nr),
841	data->block7[nr].max);
842	}
843	}
844	up(&data->update_lock);
845	}
846	}
847
848	static unsigned LM93_ALARMS_FROM_REG(struct block1_t b1)
849	{
850	unsigned result;
851	result = b1.host_status_2 & 0x3f;
852
853	if (vccp_limit_type[0])
854	result \|= (b1.host_status_4 & 0x10) << 2;
855	else
856	result \|= b1.host_status_2 & 0x40;
857
858	if (vccp_limit_type[1])
859	result \|= (b1.host_status_4 & 0x20) << 2;
860	else
861	result \|= b1.host_status_2 & 0x80;
862
863	result \|= b1.host_status_3 << 8;
864	result \|= (b1.fan_status & 0x0f) << 16;
865	result \|= (b1.p1_prochot_status & 0x80) << 13;
866	result \|= (b1.p2_prochot_status & 0x80) << 14;
867	result \|= (b1.host_status_4 & 0xfc) << 20;
868	result \|= (b1.host_status_1 & 0x07) << 28;
869	return result;
870	}
871
872	static void lm93_alarms(struct i2c_client *client, int operation,
873	int ctl_name, int nrels_mag, long results)
874	{
875	struct lm93_data *data = client->data;
876	if (operation == SENSORS_PROC_REAL_INFO)
877	*nrels_mag = 0;
878	else if (operation == SENSORS_PROC_REAL_READ) {
879	lm93_update_client(client);
880	results[0] = LM93_ALARMS_FROM_REG(data->block1);
881	*nrels_mag = 1;
882	}
883	}
884
885	#define LM93_TEMP_MIN (-1280)
886	#define LM93_TEMP_MAX ( 1270)
887
888	/* TEMP: 1/10 degrees C (-128C to +127C)
889	REG: 1C/bit, two's complement */
890	static u8 LM93_TEMP_TO_REG(int temp)
891	{
892	int ntemp = SENSORS_LIMIT(temp, LM93_TEMP_MIN, LM93_TEMP_MAX);
893	ntemp += (ntemp<0 ? -5 : 5);
894	return (u8)(ntemp / 10);
895	}
896
897	static int LM93_TEMP_FROM_REG(u8 reg)
898	{
899	return (s8)reg * 10;
900	}
901
902	static void lm93_temp(struct i2c_client *client, int operation, int ctl_name,
903	int nrels_mag, long results)
904	{
905	struct lm93_data *data = client->data;
906	int nr = ctl_name - LM93_SYSCTL_TEMP1;
907
908	if (0 > nr \|\| nr > 2)
909	return; /* ERROR */
910
911	if (operation == SENSORS_PROC_REAL_INFO)
912	*nrels_mag = 1;
913	else if (operation == SENSORS_PROC_REAL_READ) {
914	lm93_update_client(client);
915	results[0] = LM93_TEMP_FROM_REG(data->temp_lim[nr].max);
916	results[1] = LM93_TEMP_FROM_REG(data->temp_lim[nr].min);
917	results[2] = LM93_TEMP_FROM_REG(data->block2[nr]);
918	*nrels_mag = 3;
919	} else if (operation == SENSORS_PROC_REAL_WRITE) {
920	down(&data->update_lock);
921	if (*nrels_mag >= 1) {
922	data->temp_lim[nr].max = LM93_TEMP_TO_REG(results[0]);
923	lm93_write_byte(client, LM93_REG_TEMP_MAX(nr),
924	data->temp_lim[nr].max);
925	}
926	if (*nrels_mag >= 2) {
927	data->temp_lim[nr].min = LM93_TEMP_TO_REG(results[1]);
928	lm93_write_byte(client, LM93_REG_TEMP_MIN(nr),
929	data->temp_lim[nr].min);
930	}
931	up(&data->update_lock);
932	}
933	}
934
935	/* Determine 4-bit temperature offset resolution */
936	static int LM93_TEMP_OFFSET_MODE_FROM_REG(u8 sfc2, int nr)
937	{
938	/* mode: 0 => 1C/bit, nonzero => 0.5C/bit */
939	return sfc2 & (nr < 2 ? 0x10 : 0x20);
940	}
941
942	#define LM93_TEMP_OFFSET_MIN ( 0)
943	#define LM93_TEMP_OFFSET_MAX0 (150)
944	#define LM93_TEMP_OFFSET_MAX1 ( 75)
945
946	/* This function is common to all 4-bit temperature offsets
947	returns 4 bits right justified
948	mode 0 => 1C/bit, mode !0 => 0.5C/bit */
949	static u8 LM93_TEMP_OFFSET_TO_REG(int off, int mode)
950	{
951	int factor = mode ? 5 : 10;
952
953	off = SENSORS_LIMIT(off, LM93_TEMP_OFFSET_MIN,
954	mode ? LM93_TEMP_OFFSET_MAX1 : LM93_TEMP_OFFSET_MAX0);
955	return (u8)((off + factor/2) / factor);
956	}
957
958	/* This function is common to all 4-bit temperature offsets
959	reg is 4 bits right justified
960	mode 0 => 1C/bit, mode !0 => 0.5C/bit */
961	static int LM93_TEMP_OFFSET_FROM_REG(u8 reg, int mode)
962	{
963	return (reg & 0x0f) * (mode ? 5 : 10);
964	}
965
966	/* TEMP: 1/10 degrees C (0C to +15C (mode 0) or +7.5C (mode non-zero))
967	REG: 1.0C/bit (mode 0) or 0.5C/bit (mode non-zero)
968	0 <= nr <= 3 */
969	static u8 LM93_TEMP_AUTO_OFFSET_TO_REG(u8 old, int off, int nr, int mode)
970	{
971	u8 new = LM93_TEMP_OFFSET_TO_REG(off, mode);
972
973	/* temp1-temp2 (nr=0,1) use lower nibble */
974	if (nr < 2)
975	return (old & 0xf0) \| (new & 0x0f);
976
977	/* temp3-temp4 (nr=2,3) use upper nibble */
978	else
979	return (new << 4 & 0xf0) \| (old & 0x0f);
980	}
981
982	/* 0 <= nr <= 3 */
983	static int LM93_TEMP_AUTO_OFFSET_FROM_REG(u8 reg, int nr, int mode)
984	{
985	/* temp1-temp2 (nr=0,1) use lower nibble */
986	if (nr < 2)
987	return LM93_TEMP_OFFSET_FROM_REG(reg & 0x0f, mode);
988
989	/* temp3-temp4 (nr=2,3) use upper nibble */
990	else
991	return LM93_TEMP_OFFSET_FROM_REG(reg >> 4 & 0x0f, mode);
992	}
993
994	static void lm93_temp_auto_offsets(struct i2c_client *client, int operation,
995	int ctl_name, int nrels_mag, long results)
996	{
997	struct lm93_data *data = client->data;
998	int nr = ctl_name - LM93_SYSCTL_TEMP1_AUTO_OFFSETS;
999	int ii;
1000
1001	if (0 > nr \|\| nr > 2)
1002	return; /* ERROR */
1003
1004	if (operation == SENSORS_PROC_REAL_INFO)
1005	*nrels_mag = 1;
1006	else if (operation == SENSORS_PROC_REAL_READ) {
1007	int mode;
1008	lm93_update_client(client);
1009
1010	/* mode: 0 => 1C/bit, nonzero => 0.5C/bit */
1011	mode = LM93_TEMP_OFFSET_MODE_FROM_REG(data->sfc2, nr);
1012
1013	for (ii = 0; ii < 12; ii++) {
1014	results[ii] = LM93_TEMP_AUTO_OFFSET_FROM_REG(
1015	data->block10.offset[ii], nr, mode);
1016	}
1017	*nrels_mag = 12;
1018	}
1019	else if (operation == SENSORS_PROC_REAL_WRITE) {
1020	/* we only care about the first 12 values */
1021	int nrels = nrels_mag > 12 ? 12 : nrels_mag;
1022
1023	down(&data->update_lock);
1024
1025	/* force 0.5C/bit mode */
1026	data->sfc2 = lm93_read_byte(client, LM93_REG_SFC2);
1027	data->sfc2 \|= ((nr < 2) ? 0x10 : 0x20);
1028	lm93_write_byte(client, LM93_REG_SFC2, data->sfc2);
1029
1030	for (ii = 0; ii < nrels; ii++) {
1031	data->block10.offset[ii] = LM93_TEMP_AUTO_OFFSET_TO_REG(
1032	data->block10.offset[ii], results[ii], nr, 1);
1033	lm93_write_byte(client, LM93_REG_TEMP_OFFSET(ii),
1034	data->block10.offset[ii]);
1035	}
1036	up(&data->update_lock);
1037	}
1038	}
1039
1040	/* RPM: (82.5 to 1350000)
1041	REG: 14-bits, LE, left justified */
1042	static u16 LM93_FAN_TO_REG(long rpm)
1043	{
1044	u16 count, regs;
1045
1046	if (rpm == 0) {
1047	count = 0x3fff;
1048	} else {
1049	rpm = SENSORS_LIMIT(rpm, 1, 1000000);
1050	count = SENSORS_LIMIT((1350000 + rpm) / rpm, 1, 0x3ffe);
1051	}
1052
1053	regs = count << 2;
1054	return cpu_to_le16(regs);
1055	}
1056
1057	static int LM93_FAN_FROM_REG(u16 regs)
1058	{
1059	const u16 count = le16_to_cpu(regs) >> 2;
1060	return count==0 ? -1 : count==0x3fff ? 0: 1350000 / count;
1061	}
1062
1063	static void lm93_fan(struct i2c_client *client, int operation, int ctl_name,
1064	int nrels_mag, long results)
1065	{
1066	struct lm93_data *data = client->data;
1067	int nr = ctl_name - LM93_SYSCTL_FAN1;
1068
1069	if (0 > nr \|\| nr > 3)
1070	return; /* ERROR */
1071
1072	if (operation == SENSORS_PROC_REAL_INFO)
1073	*nrels_mag = 0;
1074	else if (operation == SENSORS_PROC_REAL_READ) {
1075	lm93_update_client(client);
1076	results[0] = LM93_FAN_FROM_REG(data->block8[nr]); /* min */
1077	results[1] = LM93_FAN_FROM_REG(data->block5[nr]); /* val */
1078	*nrels_mag = 2;
1079	} else if (operation == SENSORS_PROC_REAL_WRITE) {
1080	if (*nrels_mag >= 1) {
1081	down(&data->update_lock);
1082	data->block8[nr] = LM93_FAN_TO_REG(results[0]);
1083	lm93_write_word(client, LM93_REG_FAN_MIN(nr),
1084	data->block8[nr]);
1085	up(&data->update_lock);
1086	}
1087	}
1088	}
1089
1090	/* PROCHOT: 0-255, 0 => 0%, 255 => > 96.6%
1091	* REG: (same) */
1092	static u8 LM93_PROCHOT_TO_REG(long prochot)
1093	{
1094	prochot = SENSORS_LIMIT(prochot, 0, 255);
1095	return (u8)prochot;
1096	}
1097
1098	static void lm93_prochot(struct i2c_client *client, int operation,
1099	int ctl_name, int nrels_mag, long results)
1100	{
1101	struct lm93_data *data = client->data;
1102	int nr = ctl_name - LM93_SYSCTL_PROCHOT1;
1103
1104	if (0 > nr \|\| nr > 1)
1105	return; /* ERROR */
1106
1107	if (operation == SENSORS_PROC_REAL_INFO)
1108	*nrels_mag = 0;
1109	else if (operation == SENSORS_PROC_REAL_READ) {
1110	lm93_update_client(client);
1111	results[0] = data->prochot_max[nr];
1112	results[1] = data->block4[nr].cur;
1113	results[2] = data->block4[nr].avg;
1114	*nrels_mag = 3;
1115	} else if (operation == SENSORS_PROC_REAL_WRITE) {
1116	down(&data->update_lock);
1117	if (*nrels_mag >= 1) {
1118	data->prochot_max[nr] = LM93_PROCHOT_TO_REG(results[0]);
1119	lm93_write_byte(client, LM93_REG_PROCHOT_MAX(nr),
1120	data->prochot_max[nr]);
1121	}
1122	up(&data->update_lock);
1123	}
1124	}
1125
1126	/* PROCHOT-OVERRIDE; 0-15, 0 is 6.25%, 15 is 99.88%
1127	* REG: (same) */
1128	static u8 LM93_PROCHOT_OVERRIDE_TO_REG(int force1, int force2, long prochot)
1129	{
1130	u8 result = 0;
1131
1132	result \|= force1 ? 0x80 : 0x00;
1133	result \|= force2 ? 0x40 : 0x00;
1134	prochot = SENSORS_LIMIT(prochot, 0, 15);
1135	result \|= prochot;
1136	return result;
1137	}
1138
1139	static void lm93_prochot_override(struct i2c_client *client, int operation,
1140	int ctl_name, int nrels_mag, long results)
1141	{
1142	struct lm93_data *data = client->data;
1143
1144	if (ctl_name != LM93_SYSCTL_PROCHOT_OVERRIDE)
1145	return; /* ERROR */
1146
1147	if (operation == SENSORS_PROC_REAL_INFO)
1148	*nrels_mag = 0;
1149	else if (operation == SENSORS_PROC_REAL_READ) {
1150	lm93_update_client(client);
1151	results[0] = (data->prochot_override & 0x80) ? 1 : 0;
1152	results[1] = (data->prochot_override & 0x40) ? 1 : 0;
1153	results[2] = data->prochot_override & 0x0f;
1154	*nrels_mag = 3;
1155	} else if (operation == SENSORS_PROC_REAL_WRITE) {
1156
1157	/* grab old values */
1158	int force2 = (data->prochot_override & 0x40) ? 1 : 0;
1159	int prochot = data->prochot_override & 0x0f;
1160
1161	down(&data->update_lock);
1162	if (*nrels_mag >= 3) {
1163	data->prochot_override = LM93_PROCHOT_OVERRIDE_TO_REG(
1164	results[0], results[1], results[2]);
1165	}
1166	if (*nrels_mag == 2) {
1167	data->prochot_override = LM93_PROCHOT_OVERRIDE_TO_REG(
1168	results[0], results[1], prochot);
1169	}
1170	if (*nrels_mag == 1) {
1171	data->prochot_override = LM93_PROCHOT_OVERRIDE_TO_REG(
1172	results[0], force2, prochot);
1173	}
1174	if (*nrels_mag >= 1) {
1175	lm93_write_byte(client, LM93_REG_PROCHOT_OVERRIDE,
1176	data->prochot_override);
1177	}
1178	up(&data->update_lock);
1179	}
1180	}
1181
1182	/* PROCHOT-INTERVAL: 73 - 37200 (1/100 seconds)
1183	* REG: 0-9 as mapped below */
1184	static int lm93_interval_map[10] = {
1185	73, 146, 290, 580, 1170, 2330, 4660, 9320, 18600, 37200,
1186	};
1187
1188	static int LM93_INTERVAL_FROM_REG(u8 reg)
1189	{
1190	return lm93_interval_map[reg & 0x0f];
1191	}
1192
1193	/* round up to nearest match */
1194	static u8 LM93_INTERVAL_TO_REG(long interval)
1195	{
1196	int i;
1197	for (i = 0; i < 9; i++)
1198	if (interval <= lm93_interval_map[i])
1199	break;
1200
1201	/* can fall through with i==9 */
1202	return (u8)i;
1203	}
1204
1205	static void lm93_prochot_interval(struct i2c_client *client, int operation,
1206	int ctl_name, int nrels_mag, long results)
1207	{
1208	struct lm93_data *data = client->data;
1209
1210	if (ctl_name != LM93_SYSCTL_PROCHOT_INTERVAL)
1211	return; /* ERROR */
1212
1213	if (operation == SENSORS_PROC_REAL_INFO)
1214	*nrels_mag = 2;
1215	else if (operation == SENSORS_PROC_REAL_READ) {
1216	lm93_update_client(client);
1217	results[0] = LM93_INTERVAL_FROM_REG(
1218	data->prochot_interval & 0x0f);
1219	results[1] = LM93_INTERVAL_FROM_REG(
1220	(data->prochot_interval & 0xf0) >> 4);
1221	*nrels_mag = 2;
1222	} else if (operation == SENSORS_PROC_REAL_WRITE) {
1223	down(&data->update_lock);
1224	data->prochot_interval = lm93_read_byte(client,
1225	LM93_REG_PROCHOT_INTERVAL);
1226	if (*nrels_mag >= 2) {
1227	data->prochot_interval =
1228	(LM93_INTERVAL_TO_REG(results[1]) << 4) \|
1229	(data->prochot_interval & 0x0f);
1230	}
1231	if (*nrels_mag >= 1) {
1232	data->prochot_interval =
1233	(data->prochot_interval & 0xf0) \|
1234	LM93_INTERVAL_TO_REG(results[0]);
1235	lm93_write_byte(client, LM93_REG_PROCHOT_INTERVAL,
1236	data->prochot_interval);
1237	}
1238	up(&data->update_lock);
1239	}
1240	}
1241
1242	/* PWM: 0-255 per sensors documentation
1243	REG: 0-13 as mapped below... right justified */
1244	typedef enum { LM93_PWM_MAP_HI_FREQ, LM93_PWM_MAP_LO_FREQ } pwm_freq_t;
1245	static int lm93_pwm_map[2][14] = {
1246	{
1247	0x00, /* 0.00% / 0x40, / 25.00% */
1248	0x50, /* 31.25% / 0x60, / 37.50% */
1249	0x70, /* 43.75% / 0x80, / 50.00% */
1250	0x90, /* 56.25% / 0xa0, / 62.50% */
1251	0xb0, /* 68.75% / 0xc0, / 75.00% */
1252	0xd0, /* 81.25% / 0xe0, / 87.50% */
1253	0xf0, /* 93.75% / 0xff, / 100.00% */
1254	},
1255	{
1256	0x00, /* 0.00% / 0x40, / 25.00% */
1257	0x49, /* 28.57% / 0x52, / 32.14% */
1258	0x5b, /* 35.71% / 0x64, / 39.29% */
1259	0x6d, /* 42.86% / 0x76, / 46.43% */
1260	0x80, /* 50.00% / 0x89, / 53.57% */
1261	0x92, /* 57.14% / 0xb6, / 71.43% */
1262	0xdb, /* 85.71% / 0xff, / 100.00% */
1263	},
1264	};
1265
1266	static int LM93_PWM_FROM_REG(u8 reg, pwm_freq_t freq)
1267	{
1268	return lm93_pwm_map[freq][reg & 0x0f];
1269	}
1270
1271	/* round up to nearest match */
1272	static u8 LM93_PWM_TO_REG(int pwm, pwm_freq_t freq)
1273	{
1274	int i;
1275	for (i = 0; i < 13; i++)
1276	if (pwm <= lm93_pwm_map[freq][i])
1277	break;
1278
1279	/* can fall through with i==13 */
1280	return (u8)i;
1281	}
1282
1283	static void lm93_pwm(struct i2c_client *client, int operation, int ctl_name,
1284	int nrels_mag, long results)
1285	{
1286	struct lm93_data *data = client->data;
1287	int nr = ctl_name - LM93_SYSCTL_PWM1;
1288	u8 ctl2, ctl4;
1289
1290	if (0 > nr \|\| nr > 1)
1291	return; /* ERROR */
1292
1293	if (operation == SENSORS_PROC_REAL_INFO)
1294	*nrels_mag = 0;
1295	else if (operation == SENSORS_PROC_REAL_READ) {
1296	lm93_update_client(client);
1297	ctl2 = data->block9[nr][LM93_PWM_CTL2];
1298	ctl4 = data->block9[nr][LM93_PWM_CTL4];
1299	results[1] = (ctl2 & 0x01) ? 1 : 0;
1300	ctl2 = ctl2 >> 4 & 0x0f;
1301	if (results[1]) /* show user commanded value if enabled */
1302	results[0] = data->pwm_override[nr];
1303	else /* show present h/w value if manual pwm disabled */
1304	results[0] = LM93_PWM_FROM_REG(ctl2, (ctl4 & 0x07) ?
1305	LM93_PWM_MAP_LO_FREQ : LM93_PWM_MAP_HI_FREQ);
1306	*nrels_mag = 2;
1307	}
1308	else if (operation == SENSORS_PROC_REAL_WRITE) {
1309	if (*nrels_mag >= 1) {
1310	down(&data->update_lock);
1311	ctl2 = lm93_read_byte(
1312	client, LM93_REG_PWM_CTL(nr,LM93_PWM_CTL2));
1313	ctl4 = lm93_read_byte(
1314	client, LM93_REG_PWM_CTL(nr,LM93_PWM_CTL4));
1315	ctl2 = (ctl2 & 0x0f) \|
1316	LM93_PWM_TO_REG(results[0], (ctl4 & 0x07) ?
1317	LM93_PWM_MAP_LO_FREQ :
1318	LM93_PWM_MAP_HI_FREQ) << 4;
1319	if (*nrels_mag >= 2) {
1320	if (results[1])
1321	ctl2 \|= 0x01;
1322	else
1323	ctl2 &= ~0x01;
1324	}
1325	/* save user commanded value */
1326	data->pwm_override[nr] =
1327	LM93_PWM_FROM_REG(ctl2 >> 4 & 0x0f,
1328	(ctl4 & 0x07) ? LM93_PWM_MAP_LO_FREQ :
1329	LM93_PWM_MAP_HI_FREQ);
1330	lm93_write_byte(client,
1331	LM93_REG_PWM_CTL(nr,LM93_PWM_CTL2), ctl2);
1332	up(&data->update_lock);
1333	}
1334	}
1335	}
1336
1337	/* PWM FREQ: HZ
1338	REG: 0-7 as mapped below */
1339	static int lm93_pwm_freq_map[8] = {
1340	22500, 96, 84, 72, 60, 48, 36, 12
1341	};
1342
1343	static int LM93_PWM_FREQ_FROM_REG(u8 reg)
1344	{
1345	return lm93_pwm_freq_map[reg & 0x07];
1346	}
1347
1348	/* round up to nearest match */
1349	static u8 LM93_PWM_FREQ_TO_REG(int freq)
1350	{
1351	int i;
1352	for (i = 7; i > 0; i--)
1353	if (freq <= lm93_pwm_freq_map[i])
1354	break;
1355
1356	/* can fall through with i==0 */
1357	return (u8)i;
1358	}
1359
1360	/* helper function - must grab data->update_lock before calling
1361	fan is 0-3, indicating fan1-fan4 */
1362	static void lm93_write_fan_smart_tach(struct i2c_client *client,
1363	struct lm93_data *data, int fan, long value)
1364	{
1365	/* insert the new mapping and write it out */
1366	data->sf_tach_to_pwm = lm93_read_byte(client, LM93_REG_SF_TACH_TO_PWM);
1367	data->sf_tach_to_pwm &= ~(0x3 << fan * 2);
1368	data->sf_tach_to_pwm \|= value << fan * 2;
1369	lm93_write_byte(client, LM93_REG_SF_TACH_TO_PWM, data->sf_tach_to_pwm);
1370
1371	/* insert the enable bit and write it out */
1372	data->sfc2 = lm93_read_byte(client, LM93_REG_SFC2);
1373	if (value)
1374	data->sfc2 \|= 1 << fan;
1375	else
1376	data->sfc2 &= ~(1 << fan);
1377	lm93_write_byte(client, LM93_REG_SFC2, data->sfc2);
1378	}
1379
1380	/* helper function - must grab data->update_lock before calling
1381	pwm is 0-1, indicating pwm1-pwm2
1382	this disables smart tach for all tach channels bound to the given pwm */
1383	static void lm93_disable_fan_smart_tach(struct i2c_client *client,
1384	struct lm93_data *data, int pwm)
1385	{
1386	int mapping = lm93_read_byte(client, LM93_REG_SF_TACH_TO_PWM);
1387	int mask;
1388
1389	/* collapse the mapping into a mask of enable bits */
1390	mapping = (mapping >> pwm) & 0x55;
1391	mask = mapping & 0x01;
1392	mask \|= (mapping & 0x04) >> 1;
1393	mask \|= (mapping & 0x10) >> 2;
1394	mask \|= (mapping & 0x40) >> 3;
1395
1396	/* disable smart tach according to the mask */
1397	data->sfc2 = lm93_read_byte(client, LM93_REG_SFC2);
1398	data->sfc2 &= ~mask;
1399	lm93_write_byte(client, LM93_REG_SFC2, data->sfc2);
1400	}
1401
1402	static void lm93_pwm_freq(struct i2c_client *client, int operation,
1403	int ctl_name, int nrels_mag, long results)
1404	{
1405	struct lm93_data *data = client->data;
1406	int nr = ctl_name - LM93_SYSCTL_PWM1_FREQ;
1407	u8 ctl4;
1408
1409	if (0 > nr \|\| nr > 1)
1410	return; /* ERROR */
1411
1412	if (operation == SENSORS_PROC_REAL_INFO)
1413	*nrels_mag = 0;
1414	else if (operation == SENSORS_PROC_REAL_READ) {
1415	lm93_update_client(client);
1416	ctl4 = data->block9[nr][LM93_PWM_CTL4];
1417	results[0] = LM93_PWM_FREQ_FROM_REG(ctl4);
1418	*nrels_mag = 1;
1419	}
1420	else if (operation == SENSORS_PROC_REAL_WRITE) {
1421	if (*nrels_mag >= 1) {
1422	down(&data->update_lock);
1423	ctl4 = lm93_read_byte( client,
1424	LM93_REG_PWM_CTL(nr,LM93_PWM_CTL4));
1425	ctl4 = (ctl4 & 0xf8) \| LM93_PWM_FREQ_TO_REG(results[0]);
1426	data->block9[nr][LM93_PWM_CTL4] = ctl4;
1427
1428	/* ctl4 == 0 -> 22.5KHz -> disable smart tach */
1429	if (!ctl4)
1430	lm93_disable_fan_smart_tach(client, data, nr);
1431
1432	lm93_write_byte(client,
1433	LM93_REG_PWM_CTL(nr,LM93_PWM_CTL4), ctl4);
1434	up(&data->update_lock);
1435	}
1436	}
1437	}
1438
1439	/* GPIO: 0-255, GPIO0 is LSB
1440	* REG: inverted */
1441	static unsigned LM93_GPI_FROM_REG(u8 reg)
1442	{
1443	return ~reg & 0xff;
1444	}
1445
1446	static void lm93_gpio(struct i2c_client *client, int operation, int ctl_name,
1447	int nrels_mag, long results)
1448	{
1449	struct lm93_data *data = client->data;
1450
1451	if (ctl_name != LM93_SYSCTL_GPIO)
1452	return; /* ERROR */
1453
1454	if (operation == SENSORS_PROC_REAL_INFO)
1455	*nrels_mag = 0;
1456	else if (operation == SENSORS_PROC_REAL_READ) {
1457	lm93_update_client(client);
1458	results[0] = LM93_GPI_FROM_REG(data->gpi);
1459	*nrels_mag = 1;
1460	}
1461	}
1462
1463	static void lm93_temp_auto_base(struct i2c_client *client, int operation,
1464	int ctl_name, int nrels_mag, long results)
1465	{
1466	struct lm93_data *data = client->data;
1467	int nr = ctl_name - LM93_SYSCTL_TEMP1_AUTO_BASE;
1468
1469	if (0 > nr \|\| nr > 2)
1470	return; /* ERROR */
1471
1472	if (operation == SENSORS_PROC_REAL_INFO)
1473	*nrels_mag = 1;
1474	else if (operation == SENSORS_PROC_REAL_READ) {
1475	lm93_update_client(client);
1476	results[0] = LM93_TEMP_FROM_REG(data->block10.base[nr]);
1477	*nrels_mag = 1;
1478	} else if (operation == SENSORS_PROC_REAL_WRITE) {
1479	down(&data->update_lock);
1480	if (*nrels_mag >= 1) {
1481	data->block10.base[nr] = LM93_TEMP_TO_REG(results[0]);
1482	lm93_write_byte(client, LM93_REG_TEMP_BASE(nr),
1483	data->block10.base[nr]);
1484	}
1485	up(&data->update_lock);
1486	}
1487	}
1488
1489	static void lm93_temp_auto_boost(struct i2c_client *client, int operation,
1490	int ctl_name, int nrels_mag, long results)
1491	{
1492	struct lm93_data *data = client->data;
1493	int nr = ctl_name - LM93_SYSCTL_TEMP1_AUTO_BOOST;
1494
1495	if (0 > nr \|\| nr > 2)
1496	return; /* ERROR */
1497
1498	if (operation == SENSORS_PROC_REAL_INFO)
1499	*nrels_mag = 1;
1500	else if (operation == SENSORS_PROC_REAL_READ) {
1501	lm93_update_client(client);
1502	results[0] = LM93_TEMP_FROM_REG(data->boost[nr]);
1503	*nrels_mag = 1;
1504	} else if (operation == SENSORS_PROC_REAL_WRITE) {
1505	down(&data->update_lock);
1506	if (*nrels_mag >= 1) {
1507	data->boost[nr] = LM93_TEMP_TO_REG(results[0]);
1508	lm93_write_byte(client, LM93_REG_BOOST(nr),
1509	data->boost[nr]);
1510	}
1511	up(&data->update_lock);
1512	}
1513
1514	}
1515
1516	static u8 LM93_AUTO_BOOST_HYST_TO_REG(struct lm93_data *data, long hyst,
1517	int nr, int mode)
1518	{
1519	u8 reg = LM93_TEMP_OFFSET_TO_REG(
1520	(LM93_TEMP_FROM_REG(data->boost[nr]) - hyst), mode);
1521
1522	switch (nr) {
1523	case 0:
1524	reg = (data->boost_hyst[0] & 0xf0) \| (reg & 0x0f);
1525	break;
1526	case 1:
1527	reg = (reg << 4 & 0xf0) \| (data->boost_hyst[0] & 0x0f);
1528	break;
1529	case 2:
1530	reg = (data->boost_hyst[1] & 0xf0) \| (reg & 0x0f);
1531	break;
1532	case 3:
1533	default:
1534	reg = (reg << 4 & 0xf0) \| (data->boost_hyst[1] & 0x0f);
1535	break;
1536	}
1537
1538	return reg;
1539	}
1540
1541	static int LM93_AUTO_BOOST_HYST_FROM_REGS(struct lm93_data *data, int nr,
1542	int mode)
1543	{
1544	u8 reg;
1545
1546	switch (nr) {
1547	case 0:
1548	reg = data->boost_hyst[0] & 0x0f;
1549	break;
1550	case 1:
1551	reg = data->boost_hyst[0] >> 4 & 0x0f;
1552	break;
1553	case 2:
1554	reg = data->boost_hyst[1] & 0x0f;
1555	break;
1556	case 3:
1557	default:
1558	reg = data->boost_hyst[1] >> 4 & 0x0f;
1559	break;
1560	}
1561
1562	return LM93_TEMP_FROM_REG(data->boost[nr]) -
1563	LM93_TEMP_OFFSET_FROM_REG(reg, mode);
1564	}
1565
1566	static void lm93_temp_auto_boost_hyst(struct i2c_client *client, int operation,
1567	int ctl_name, int nrels_mag, long results)
1568	{
1569	struct lm93_data *data = client->data;
1570	int nr = ctl_name - LM93_SYSCTL_TEMP1_AUTO_BOOST_HYST;
1571
1572	if (0 > nr \|\| nr > 2)
1573	return; /* ERROR */
1574
1575	if (operation == SENSORS_PROC_REAL_INFO)
1576	*nrels_mag = 1;
1577	else if (operation == SENSORS_PROC_REAL_READ) {
1578	int mode;
1579	lm93_update_client(client);
1580
1581	/* mode: 0 => 1C/bit, nonzero => 0.5C/bit */
1582	mode = LM93_TEMP_OFFSET_MODE_FROM_REG(data->sfc2, nr);
1583
1584	results[0] = LM93_AUTO_BOOST_HYST_FROM_REGS(data, nr, mode);
1585	*nrels_mag = 1;
1586	} else if (operation == SENSORS_PROC_REAL_WRITE) {
1587	if (*nrels_mag >= 1) {
1588	down(&data->update_lock);
1589
1590	/* force 0.5C/bit mode */
1591	data->sfc2 = lm93_read_byte(client, LM93_REG_SFC2);
1592	data->sfc2 \|= ((nr < 2) ? 0x10 : 0x20);
1593	lm93_write_byte(client, LM93_REG_SFC2, data->sfc2);
1594
1595	data->boost_hyst[nr/2] =
1596	LM93_AUTO_BOOST_HYST_TO_REG(data,
1597	results[0], nr, 1);
1598	lm93_write_byte(client, LM93_REG_BOOST_HYST(nr),
1599	data->boost_hyst[nr/2]);
1600	up(&data->update_lock);
1601	}
1602	}
1603	}
1604
1605	static void lm93_temp_auto_pwm_min(struct i2c_client *client, int operation,
1606	int ctl_name, int nrels_mag, long results)
1607	{
1608	struct lm93_data *data = client->data;
1609	int nr = ctl_name - LM93_SYSCTL_TEMP1_AUTO_PWM_MIN;
1610	u8 reg, ctl4;
1611
1612	if (0 > nr \|\| nr > 2)
1613	return; /* ERROR */
1614
1615	if (operation == SENSORS_PROC_REAL_INFO)
1616	*nrels_mag = 0;
1617	else if (operation == SENSORS_PROC_REAL_READ) {
1618	lm93_update_client(client);
1619	reg = data->auto_pwm_min_hyst[nr/2] >> 4 & 0x0f;
1620	ctl4 = data->block9[nr][LM93_PWM_CTL4];
1621	results[0] = LM93_PWM_FROM_REG(reg, (ctl4 & 0x07) ?
1622	LM93_PWM_MAP_LO_FREQ : LM93_PWM_MAP_HI_FREQ);
1623	*nrels_mag = 1;
1624	} else if (operation == SENSORS_PROC_REAL_WRITE) {
1625	if (*nrels_mag >= 1) {
1626	down(&data->update_lock);
1627	reg = lm93_read_byte(client, LM93_REG_PWM_MIN_HYST(nr));
1628	ctl4 = lm93_read_byte(
1629	client, LM93_REG_PWM_CTL(nr,LM93_PWM_CTL4));
1630	reg = (reg & 0x0f) \|
1631	LM93_PWM_TO_REG(results[0], (ctl4 & 0x07) ?
1632	LM93_PWM_MAP_LO_FREQ :
1633	LM93_PWM_MAP_HI_FREQ) << 4;
1634
1635	data->auto_pwm_min_hyst[nr/2] = reg;
1636	lm93_write_byte(client, LM93_REG_PWM_MIN_HYST(nr), reg);
1637	up(&data->update_lock);
1638	}
1639	}
1640	}
1641
1642	static void lm93_temp_auto_offset_hyst(struct i2c_client *client, int operation,
1643	int ctl_name, int nrels_mag, long results)
1644	{
1645	struct lm93_data *data = client->data;
1646	int nr = ctl_name - LM93_SYSCTL_TEMP1_AUTO_OFFSET_HYST;
1647
1648	if (0 > nr \|\| nr > 2)
1649	return; /* ERROR */
1650
1651	if (operation == SENSORS_PROC_REAL_INFO)
1652	*nrels_mag = 1;
1653	else if (operation == SENSORS_PROC_REAL_READ) {
1654	int mode;
1655	lm93_update_client(client);
1656
1657	/* mode: 0 => 1C/bit, nonzero => 0.5C/bit */
1658	mode = LM93_TEMP_OFFSET_MODE_FROM_REG(data->sfc2, nr);
1659
1660	results[0] = LM93_TEMP_OFFSET_FROM_REG(
1661	data->auto_pwm_min_hyst[nr/2], mode);
1662
1663	*nrels_mag = 1;
1664	} else if (operation == SENSORS_PROC_REAL_WRITE) {
1665	if (*nrels_mag >= 1) {
1666	u8 reg;
1667	down(&data->update_lock);
1668
1669	/* force 0.5C/bit mode */
1670	data->sfc2 = lm93_read_byte(client, LM93_REG_SFC2);
1671	data->sfc2 \|= ((nr < 2) ? 0x10 : 0x20);
1672	lm93_write_byte(client, LM93_REG_SFC2, data->sfc2);
1673
1674	reg = data->auto_pwm_min_hyst[nr/2];
1675	reg = (reg & 0xf0) \|
1676	(LM93_TEMP_OFFSET_TO_REG(results[0], 1) & 0x0f);
1677
1678	data->auto_pwm_min_hyst[nr/2] = reg;
1679	lm93_write_byte(client, LM93_REG_PWM_MIN_HYST(nr), reg);
1680	up(&data->update_lock);
1681	}
1682	}
1683	}
1684
1685	/* some tedious bit-twiddling here to deal with the register format:
1686
1687	data->sf_tach_to_pwm: (tach to pwm mapping bits)
1688
1689	bit \| 7 \| 6 \| 5 \| 4 \| 3 \| 2 \| 1 \| 0
1690	T4:P2 T4:P1 T3:P2 T3:P1 T2:P2 T2:P1 T1:P2 T1:P1
1691
1692	data->sfc2: (enable bits)
1693
1694	bit \| 3 \| 2 \| 1 \| 0
1695	T4 T3 T2 T1
1696	*/
1697
1698	static void lm93_fan_smart_tach(struct i2c_client *client, int operation,
1699	int ctl_name, int nrels_mag, long results)
1700	{
1701	struct lm93_data *data = client->data;
1702	int nr = ctl_name - LM93_SYSCTL_FAN1_SMART_TACH;
1703
1704	if (0 > nr \|\| nr > 3)
1705	return; /* ERROR */
1706
1707	if (operation == SENSORS_PROC_REAL_INFO)
1708	*nrels_mag = 0;
1709	else if (operation == SENSORS_PROC_REAL_READ) {
1710	int mapping;
1711
1712	lm93_update_client(client);
1713
1714	/* extract the relevant mapping */
1715	mapping = (data->sf_tach_to_pwm >> (nr * 2)) & 0x03;
1716
1717	/* if there's a mapping and it's enabled */
1718	if (mapping && ((data->sfc2 >> nr) & 0x01))
1719	results[0] = mapping;
1720	else
1721	results[0] = 0;
1722
1723	*nrels_mag = 1;
1724
1725	} else if (operation == SENSORS_PROC_REAL_WRITE) {
1726	if (*nrels_mag >= 1) {
1727	down(&data->update_lock);
1728
1729	/* sanity test, ignore the write otherwise */
1730	if (0 <= results[0] && results[0] <= 2) {
1731
1732	/* can't enable if pwm freq is 22.5KHz */
1733	if (results[0]) {
1734	u8 ctl4 = lm93_read_byte(client,
1735	LM93_REG_PWM_CTL(results[0]-1,
1736	LM93_PWM_CTL4));
1737	if ((ctl4 & 0x07) == 0)
1738	results[0] = 0;
1739	}
1740
1741	lm93_write_fan_smart_tach(client, data, nr,
1742	results[0]);
1743	}
1744	up(&data->update_lock);
1745	}
1746	}
1747	}
1748
1749	static void lm93_prochot_short(struct i2c_client *client, int operation,
1750	int ctl_name, int nrels_mag, long results)
1751	{
1752	struct lm93_data *data = client->data;
1753
1754	if (ctl_name != LM93_SYSCTL_PROCHOT_SHORT)
1755	return; /* ERROR */
1756
1757	if (operation == SENSORS_PROC_REAL_INFO)
1758	*nrels_mag = 0;
1759	else if (operation == SENSORS_PROC_REAL_READ) {
1760	lm93_update_client(client);
1761	results[0] = (data->config & 0x10) ? 1 : 0;
1762	*nrels_mag = 1;
1763	} else if (operation == SENSORS_PROC_REAL_WRITE) {
1764	down(&data->update_lock);
1765	if (*nrels_mag >= 1) {
1766	if (results[0])
1767	data->config \|= 0x10;
1768	else
1769	data->config &= ~0x10;
1770	lm93_write_byte(client, LM93_REG_CONFIG, data->config);
1771	}
1772	up(&data->update_lock);
1773	}
1774	}
1775
1776	static void lm93_vrdhot(struct i2c_client *client, int operation,
1777	int ctl_name, int nrels_mag, long results)
1778	{
1779	struct lm93_data *data = client->data;
1780	int nr = ctl_name - LM93_SYSCTL_VRDHOT1;
1781
1782	if (0 > nr \|\| nr > 1)
1783	return; /* ERROR */
1784
1785	if (operation == SENSORS_PROC_REAL_INFO)
1786	*nrels_mag = 0;
1787	else if (operation == SENSORS_PROC_REAL_READ) {
1788	lm93_update_client(client);
1789	results[0] = data->block1.host_status_1 & (1 << (nr+4)) ? 1 : 0;
1790	*nrels_mag = 1;
1791	}
1792	}
1793
1794	static void lm93_pwm_auto_chan(struct i2c_client *client, int operation,
1795	int ctl_name, int nrels_mag, long results)
1796	{
1797	struct lm93_data *data = client->data;
1798	int nr = ctl_name - LM93_SYSCTL_PWM1_AUTO_CHANNELS;
1799
1800	if (0 > nr \|\| nr > 1)
1801	return; /* ERROR */
1802
1803	if (operation == SENSORS_PROC_REAL_INFO)
1804	*nrels_mag = 0;
1805	else if (operation == SENSORS_PROC_REAL_READ) {
1806	lm93_update_client(client);
1807	results[0] = data->block9[nr][LM93_PWM_CTL1];
1808	*nrels_mag = 1;
1809	}
1810	else if (operation == SENSORS_PROC_REAL_WRITE) {
1811	if (*nrels_mag >= 1) {
1812	down(&data->update_lock);
1813	data->block9[nr][LM93_PWM_CTL1] =
1814	SENSORS_LIMIT(results[0], 0, 255);
1815	lm93_write_byte(client,
1816	LM93_REG_PWM_CTL(nr,LM93_PWM_CTL1),
1817	data->block9[nr][LM93_PWM_CTL1]);
1818	up(&data->update_lock);
1819	}
1820	}
1821	}
1822
1823	static void lm93_pwm_auto_spinup_min(struct i2c_client *client, int operation,
1824	int ctl_name, int nrels_mag, long results)
1825	{
1826	struct lm93_data *data = client->data;
1827	int nr = ctl_name - LM93_SYSCTL_PWM1_AUTO_SPINUP_MIN;
1828	u8 ctl3, ctl4;
1829
1830	if (0 > nr \|\| nr > 1)
1831	return; /* ERROR */
1832
1833	if (operation == SENSORS_PROC_REAL_INFO)
1834	*nrels_mag = 0;
1835	else if (operation == SENSORS_PROC_REAL_READ) {
1836	lm93_update_client(client);
1837	ctl3 = data->block9[nr][LM93_PWM_CTL3];
1838	ctl4 = data->block9[nr][LM93_PWM_CTL4];
1839	results[0] = LM93_PWM_FROM_REG(ctl3 & 0x0f, (ctl4 & 0x07) ?
1840	LM93_PWM_MAP_LO_FREQ : LM93_PWM_MAP_HI_FREQ);
1841	*nrels_mag = 1;
1842	}
1843	else if (operation == SENSORS_PROC_REAL_WRITE) {
1844	if (*nrels_mag >= 1) {
1845	down(&data->update_lock);
1846	ctl3 = lm93_read_byte(client,
1847	LM93_REG_PWM_CTL(nr, LM93_PWM_CTL3));
1848	ctl4 = lm93_read_byte(client,
1849	LM93_REG_PWM_CTL(nr, LM93_PWM_CTL4));
1850	ctl3 = (ctl3 & 0xf0) \|
1851	LM93_PWM_TO_REG(results[0], (ctl4 & 0x07) ?
1852	LM93_PWM_MAP_LO_FREQ :
1853	LM93_PWM_MAP_HI_FREQ);
1854	data->block9[nr][LM93_PWM_CTL3] = ctl3;
1855	lm93_write_byte(client,
1856	LM93_REG_PWM_CTL(nr, LM93_PWM_CTL3), ctl3);
1857	up(&data->update_lock);
1858	}
1859	}
1860	}
1861
1862	/* TIME: 1/100 seconds
1863	* REG: 0-7 as mapped below */
1864	static int lm93_spinup_time_map[8] = {
1865	0, 10, 25, 40, 70, 100, 200, 400,
1866	};
1867
1868	static int LM93_SPINUP_TIME_FROM_REG(u8 reg)
1869	{
1870	return lm93_spinup_time_map[reg >> 5 & 0x07];
1871	}
1872
1873	/* round up to nearest match */
1874	static u8 LM93_SPINUP_TIME_TO_REG(int time)
1875	{
1876	int i;
1877	for (i = 0; i < 7; i++)
1878	if (time <= lm93_spinup_time_map[i])
1879	break;
1880
1881	/* can fall through with i==8 */
1882	return (u8)i;
1883	}
1884
1885	static void lm93_pwm_auto_spinup_time(struct i2c_client *client, int operation,
1886	int ctl_name, int nrels_mag, long results)
1887	{
1888	struct lm93_data *data = client->data;
1889	int nr = ctl_name - LM93_SYSCTL_PWM1_AUTO_SPINUP_TIME;
1890
1891	if (0 > nr \|\| nr > 1)
1892	return; /* ERROR */
1893
1894	if (operation == SENSORS_PROC_REAL_INFO)
1895	*nrels_mag = 2;
1896	else if (operation == SENSORS_PROC_REAL_READ) {
1897	lm93_update_client(client);
1898	results[0] = LM93_SPINUP_TIME_FROM_REG(
1899	data->block9[nr][LM93_PWM_CTL3]);
1900	*nrels_mag = 1;
1901	}
1902	else if (operation == SENSORS_PROC_REAL_WRITE) {
1903	if (*nrels_mag >= 1) {
1904	u8 ctl3;
1905	down(&data->update_lock);
1906	ctl3 = lm93_read_byte(client,
1907	LM93_REG_PWM_CTL(nr, LM93_PWM_CTL3));
1908	ctl3 = (ctl3 & 0x1f) \| (LM93_SPINUP_TIME_TO_REG(
1909	results[0]) << 5 & 0xe0);
1910	data->block9[nr][LM93_PWM_CTL3] = ctl3;
1911	lm93_write_byte(client,
1912	LM93_REG_PWM_CTL(nr, LM93_PWM_CTL3), ctl3);
1913	up(&data->update_lock);
1914	}
1915	}
1916	}
1917
1918	#define LM93_RAMP_MIN 0
1919	#define LM93_RAMP_MAX 75
1920
1921	/* RAMP: 1/100 seconds
1922	REG: 50mS/bit 4-bits right justified */
1923	static u8 LM93_RAMP_TO_REG(int ramp)
1924	{
1925	ramp = SENSORS_LIMIT(ramp, LM93_RAMP_MIN, LM93_RAMP_MAX);
1926	return (u8)((ramp + 2) / 5);
1927	}
1928
1929	static int LM93_RAMP_FROM_REG(u8 reg)
1930	{
1931	return (reg & 0x0f) * 5;
1932	}
1933
1934	static void lm93_pwm_auto_ramp(struct i2c_client *client, int operation,
1935	int ctl_name, int nrels_mag, long results)
1936	{
1937	struct lm93_data *data = client->data;
1938
1939	if (!(ctl_name == LM93_SYSCTL_PWM_AUTO_PROCHOT_RAMP \|\|
1940	ctl_name == LM93_SYSCTL_PWM_AUTO_VRDHOT_RAMP))
1941	return; /* ERROR */
1942
1943	if (operation == SENSORS_PROC_REAL_INFO)
1944	*nrels_mag = 2;
1945	else if (operation == SENSORS_PROC_REAL_READ) {
1946	lm93_update_client(client);
1947	if (ctl_name == LM93_SYSCTL_PWM_AUTO_PROCHOT_RAMP)
1948	results[0] = LM93_RAMP_FROM_REG(
1949	data->pwm_ramp_ctl >> 4 & 0x0f);
1950	else
1951	results[0] = LM93_RAMP_FROM_REG(
1952	data->pwm_ramp_ctl & 0x0f);
1953	*nrels_mag = 1;
1954	}
1955	else if (operation == SENSORS_PROC_REAL_WRITE) {
1956	if (*nrels_mag >= 1) {
1957	u8 ramp;
1958	down(&data->update_lock);
1959	ramp = lm93_read_byte(client, LM93_REG_PWM_RAMP_CTL);
1960	if (ctl_name == LM93_SYSCTL_PWM_AUTO_PROCHOT_RAMP)
1961	ramp = (ramp & 0x0f) \| (LM93_RAMP_TO_REG(
1962	results[0]) << 4 & 0xf0);
1963	else
1964	ramp = (ramp & 0xf0) \| (LM93_RAMP_TO_REG(
1965	results[0]) & 0x0f);
1966	lm93_write_byte(client, LM93_REG_PWM_RAMP_CTL, ramp);
1967	up(&data->update_lock);
1968	}
1969	}
1970	}
1971
1972	/* These files are created for each detected LM93. This is just a template;
1973	though at first sight, you might think we could use a statically
1974	allocated list, we need some way to get back to the parent - which
1975	is done through one of the 'extra' fields which are initialized
1976	when a new copy is allocated. */
1977
1978	#define LM93_SYSCTL_IN(nr) {LM93_SYSCTL_IN##nr, "in" #nr, NULL, 0, \
1979	0644, NULL, &i2c_proc_real, &i2c_sysctl_real, NULL, &lm93_in}
1980	#define LM93_SYSCTL_TEMP(nr) {LM93_SYSCTL_TEMP##nr, "temp" #nr, NULL, 0, \
1981	0644, NULL, &i2c_proc_real, &i2c_sysctl_real, NULL, &lm93_temp}
1982	#define LM93_SYSCTL_TEMP_AUTO_BASE(nr) {LM93_SYSCTL_TEMP##nr##_AUTO_BASE, \
1983	"temp" #nr "_auto_base", NULL, 0, 0644, NULL, &i2c_proc_real, \
1984	&i2c_sysctl_real, NULL, &lm93_temp_auto_base}
1985	#define LM93_SYSCTL_TEMP_AUTO_OFFSETS(nr) {LM93_SYSCTL_TEMP##nr##_AUTO_OFFSETS,\
1986	"temp" #nr "_auto_offsets", NULL, 0, 0644, NULL, &i2c_proc_real, \
1987	&i2c_sysctl_real, NULL, &lm93_temp_auto_offsets}
1988	#define LM93_SYSCTL_TEMP_AUTO_BOOST(nr) { LM93_SYSCTL_TEMP##nr##_AUTO_BOOST, \
1989	"temp" #nr "_auto_boost", NULL, 0, 0644, NULL, &i2c_proc_real, \
1990	&i2c_sysctl_real, NULL, &lm93_temp_auto_boost}
1991	#define LM93_SYSCTL_TEMP_AUTO_BOOST_HYST(nr) { \
1992	LM93_SYSCTL_TEMP##nr##_AUTO_BOOST_HYST, "temp" #nr "_auto_boost_hyst", \
1993	NULL, 0, 0644, NULL, &i2c_proc_real, &i2c_sysctl_real, NULL, \
1994	&lm93_temp_auto_boost_hyst}
1995	#define LM93_SYSCTL_TEMP_AUTO_PWM_MIN(nr) { \
1996	LM93_SYSCTL_TEMP##nr##_AUTO_PWM_MIN, "temp" #nr "_auto_pwm_min", \
1997	NULL, 0, 0644, NULL, &i2c_proc_real, &i2c_sysctl_real, NULL, \
1998	&lm93_temp_auto_pwm_min}
1999	#define LM93_SYSCTL_TEMP_AUTO_OFFSET_HYST(nr) { \
2000	LM93_SYSCTL_TEMP##nr##_AUTO_OFFSET_HYST,"temp" #nr "_auto_offset_hyst",\
2001	NULL, 0, 0644, NULL, &i2c_proc_real, &i2c_sysctl_real, NULL, \
2002	&lm93_temp_auto_offset_hyst}
2003	#define LM93_SYSCTL_PWM(nr) {LM93_SYSCTL_PWM##nr, "pwm" #nr, NULL, 0, \
2004	0644, NULL, &i2c_proc_real, &i2c_sysctl_real, NULL, &lm93_pwm}
2005	#define LM93_SYSCTL_PWM_FREQ(nr) {LM93_SYSCTL_PWM##nr##_FREQ, \
2006	"pwm" #nr "_freq", NULL, 0, 0644, NULL, &i2c_proc_real, \
2007	&i2c_sysctl_real, NULL, &lm93_pwm_freq}
2008	#define LM93_SYSCTL_PWM_AUTO_CHAN(nr) {LM93_SYSCTL_PWM##nr##_AUTO_CHANNELS, \
2009	"pwm" #nr "_auto_channels", NULL, 0, 0644, NULL, &i2c_proc_real, \
2010	&i2c_sysctl_real, NULL, &lm93_pwm_auto_chan}
2011	#define LM93_SYSCTL_PWM_AUTO_SPINUP_MIN(nr) { \
2012	LM93_SYSCTL_PWM##nr##_AUTO_SPINUP_MIN, "pwm" #nr "_auto_spinup_min", \
2013	NULL, 0, 0644, NULL, &i2c_proc_real, &i2c_sysctl_real, NULL, \
2014	&lm93_pwm_auto_spinup_min}
2015	#define LM93_SYSCTL_PWM_AUTO_SPINUP_TIME(nr) { \
2016	LM93_SYSCTL_PWM##nr##_AUTO_SPINUP_TIME, "pwm" #nr "_auto_spinup_time", \
2017	NULL, 0, 0644, NULL, &i2c_proc_real, &i2c_sysctl_real, NULL, \
2018	&lm93_pwm_auto_spinup_time}
2019	#define LM93_SYSCTL_FAN(nr) {LM93_SYSCTL_FAN##nr, "fan" #nr, NULL, 0, \
2020	0644, NULL, &i2c_proc_real, &i2c_sysctl_real, NULL, &lm93_fan}
2021	#define LM93_SYSCTL_VID(nr) {LM93_SYSCTL_VID##nr, "vid" #nr, NULL, 0, \
2022	0444, NULL, &i2c_proc_real, &i2c_sysctl_real, NULL, &lm93_vid}
2023	#define LM93_SYSCTL_PROCHOT(nr) {LM93_SYSCTL_PROCHOT##nr, "prochot" #nr, NULL, \
2024	0, 0644, NULL, &i2c_proc_real, &i2c_sysctl_real, NULL, &lm93_prochot}
2025	#define LM93_SYSCTL_VRDHOT(nr) {LM93_SYSCTL_VRDHOT##nr, "vrdhot" #nr, NULL, \
2026	0, 0444, NULL, &i2c_proc_real, &i2c_sysctl_real, NULL, &lm93_vrdhot}
2027	#define LM93_SYSCTL_FAN_SMART_TACH(nr) {LM93_SYSCTL_FAN##nr##_SMART_TACH, \
2028	"fan" #nr "_smart_tach", NULL, 0, 0644, NULL, &i2c_proc_real, \
2029	&i2c_sysctl_real, NULL, &lm93_fan_smart_tach}
2030	static ctl_table lm93_dir_table_template[] = {
2031	LM93_SYSCTL_IN(1),
2032	LM93_SYSCTL_IN(2),
2033	LM93_SYSCTL_IN(3),
2034	LM93_SYSCTL_IN(4),
2035	LM93_SYSCTL_IN(5),
2036	LM93_SYSCTL_IN(6),
2037	LM93_SYSCTL_IN(7),
2038	LM93_SYSCTL_IN(8),
2039	LM93_SYSCTL_IN(9),
2040	LM93_SYSCTL_IN(10),
2041	LM93_SYSCTL_IN(11),
2042	LM93_SYSCTL_IN(12),
2043	LM93_SYSCTL_IN(13),
2044	LM93_SYSCTL_IN(14),
2045	LM93_SYSCTL_IN(15),
2046	LM93_SYSCTL_IN(16),
2047
2048	LM93_SYSCTL_TEMP(1),
2049	LM93_SYSCTL_TEMP(2),
2050	LM93_SYSCTL_TEMP(3),
2051
2052	LM93_SYSCTL_TEMP_AUTO_BASE(1),
2053	LM93_SYSCTL_TEMP_AUTO_BASE(2),
2054	LM93_SYSCTL_TEMP_AUTO_BASE(3),
2055
2056	LM93_SYSCTL_TEMP_AUTO_OFFSETS(1),
2057	LM93_SYSCTL_TEMP_AUTO_OFFSETS(2),
2058	LM93_SYSCTL_TEMP_AUTO_OFFSETS(3),
2059
2060	LM93_SYSCTL_TEMP_AUTO_BOOST(1),
2061	LM93_SYSCTL_TEMP_AUTO_BOOST(2),
2062	LM93_SYSCTL_TEMP_AUTO_BOOST(3),
2063
2064	LM93_SYSCTL_TEMP_AUTO_BOOST_HYST(1),
2065	LM93_SYSCTL_TEMP_AUTO_BOOST_HYST(2),
2066	LM93_SYSCTL_TEMP_AUTO_BOOST_HYST(3),
2067
2068	LM93_SYSCTL_TEMP_AUTO_PWM_MIN(1),
2069	LM93_SYSCTL_TEMP_AUTO_PWM_MIN(2),
2070	LM93_SYSCTL_TEMP_AUTO_PWM_MIN(3),
2071
2072	LM93_SYSCTL_TEMP_AUTO_OFFSET_HYST(1),
2073	LM93_SYSCTL_TEMP_AUTO_OFFSET_HYST(2),
2074	LM93_SYSCTL_TEMP_AUTO_OFFSET_HYST(3),
2075
2076	LM93_SYSCTL_FAN(1),
2077	LM93_SYSCTL_FAN(2),
2078	LM93_SYSCTL_FAN(3),
2079	LM93_SYSCTL_FAN(4),
2080
2081	LM93_SYSCTL_FAN_SMART_TACH(1),
2082	LM93_SYSCTL_FAN_SMART_TACH(2),
2083	LM93_SYSCTL_FAN_SMART_TACH(3),
2084	LM93_SYSCTL_FAN_SMART_TACH(4),
2085
2086	LM93_SYSCTL_PWM(1),
2087	LM93_SYSCTL_PWM(2),
2088
2089	LM93_SYSCTL_PWM_FREQ(1),
2090	LM93_SYSCTL_PWM_FREQ(2),
2091
2092	LM93_SYSCTL_PWM_AUTO_CHAN(1),
2093	LM93_SYSCTL_PWM_AUTO_CHAN(2),
2094
2095	LM93_SYSCTL_PWM_AUTO_SPINUP_MIN(1),
2096	LM93_SYSCTL_PWM_AUTO_SPINUP_MIN(2),
2097
2098	LM93_SYSCTL_PWM_AUTO_SPINUP_TIME(1),
2099	LM93_SYSCTL_PWM_AUTO_SPINUP_TIME(2),
2100
2101	{LM93_SYSCTL_PWM_AUTO_PROCHOT_RAMP, "pwm_auto_prochot_ramp", NULL, 0,
2102	0644, NULL, &i2c_proc_real, &i2c_sysctl_real, NULL,
2103	&lm93_pwm_auto_ramp},
2104
2105	{LM93_SYSCTL_PWM_AUTO_VRDHOT_RAMP, "pwm_auto_vrdhot_ramp", NULL, 0,
2106	0644, NULL, &i2c_proc_real, &i2c_sysctl_real, NULL,
2107	&lm93_pwm_auto_ramp},
2108
2109	LM93_SYSCTL_VID(1),
2110	LM93_SYSCTL_VID(2),
2111
2112	LM93_SYSCTL_PROCHOT(1),
2113	LM93_SYSCTL_PROCHOT(2),
2114
2115	{LM93_SYSCTL_PROCHOT_SHORT, "prochot_short", NULL, 0, 0644, NULL,
2116	&i2c_proc_real, &i2c_sysctl_real, NULL, &lm93_prochot_short},
2117
2118	{LM93_SYSCTL_PROCHOT_OVERRIDE, "prochot_override", NULL, 0, 0644, NULL,
2119	&i2c_proc_real, &i2c_sysctl_real, NULL, &lm93_prochot_override},
2120
2121	{LM93_SYSCTL_PROCHOT_INTERVAL, "prochot_interval", NULL, 0, 0644, NULL,
2122	&i2c_proc_real, &i2c_sysctl_real, NULL, &lm93_prochot_interval},
2123
2124	LM93_SYSCTL_VRDHOT(1),
2125	LM93_SYSCTL_VRDHOT(2),
2126
2127	{LM93_SYSCTL_GPIO, "gpio", NULL, 0, 0444, NULL,
2128	&i2c_proc_real, &i2c_sysctl_real, NULL, &lm93_gpio},
2129
2130	{LM93_SYSCTL_ALARMS, "alarms", NULL, 0, 0444, NULL, &i2c_proc_real,
2131	&i2c_sysctl_real, NULL, &lm93_alarms},
2132
2133	{0}
2134	};
2135
2136	static void lm93_init_client(struct i2c_client *client)
2137	{
2138	int i;
2139	u8 reg;
2140
2141	/* configure VID pin input thresholds */
2142	reg = lm93_read_byte(client, LM93_REG_GPI_VID_CTL);
2143	lm93_write_byte(client, LM93_REG_GPI_VID_CTL,
2144	reg \| (vid_agtl ? 0x03 : 0x00));
2145
2146	if (init) {
2147	/* enable #ALERT pin */
2148	reg = lm93_read_byte(client, LM93_REG_CONFIG);
2149	lm93_write_byte(client, LM93_REG_CONFIG, reg \| 0x08);
2150
2151	/* enable ASF mode for BMC status registers */
2152	reg = lm93_read_byte(client, LM93_REG_STATUS_CONTROL);
2153	lm93_write_byte(client, LM93_REG_STATUS_CONTROL, reg \| 0x02);
2154
2155	/* set sleep state to S0 */
2156	lm93_write_byte(client, LM93_REG_SLEEP_CONTROL, 0);
2157
2158	/* unmask #VRDHOT and dynamic VCCP (if nec) error events */
2159	reg = lm93_read_byte(client, LM93_REG_MISC_ERR_MASK);
2160	reg &= ~0x03;
2161	reg &= ~(vccp_limit_type[0] ? 0x10 : 0);
2162	reg &= ~(vccp_limit_type[1] ? 0x20 : 0);
2163	lm93_write_byte(client, LM93_REG_MISC_ERR_MASK, reg);
2164	}
2165
2166	/* start monitoring */
2167	reg = lm93_read_byte(client, LM93_REG_CONFIG);
2168	lm93_write_byte(client, LM93_REG_CONFIG, reg \| 0x01);
2169
2170	/* spin until ready */
2171	for (i=0; i<20; i++) {
2172	mdelay(10);
2173	if ((lm93_read_byte(client, LM93_REG_CONFIG) & 0x80) == 0x80)
2174	return;
2175	}
2176
2177	printk(KERN_WARNING "lm93.o: timed out waiting for sensor "
2178	"chip to signal ready!\n");
2179	}
2180
2181	/* forward declaration */
2182	static struct i2c_driver lm93_driver;
2183
2184	/* This function is called by i2c_detect */
2185	static int lm93_detect(struct i2c_adapter *adapter, int address,
2186	unsigned short flags, int kind)
2187	{
2188	int err = 0, func;
2189	struct lm93_data *data;
2190	struct i2c_client *client;
2191	void (update)(struct lm93_data , struct i2c_client *);
2192
2193	/* lm93 is SMBus only */
2194	if (i2c_is_isa_adapter(adapter)) {
2195	pr_debug("lm93.o: detect failed, "
2196	"cannot attach to legacy adapter!\n");
2197	goto ERROR0;
2198	}
2199
2200	/* choose update routine based on bus capabilities */
2201	func = i2c_get_functionality(adapter);
2202
2203	if ( ((LM93_SMBUS_FUNC_FULL & func) == LM93_SMBUS_FUNC_FULL) &&
2204	(!disable_block) ) {
2205	pr_debug("lm93.o: using SMBus block data transactions\n");
2206	update = lm93_update_client_full;
2207	} else if ((LM93_SMBUS_FUNC_MIN & func) == LM93_SMBUS_FUNC_MIN) {
2208	pr_debug("lm93.o: disabled SMBus block data transactions\n");
2209	update = lm93_update_client_min;
2210	} else {
2211	pr_debug("lm93.o: detect failed, "
2212	"smbus byte and/or word data not supported!\n");
2213	goto ERROR0;
2214	}
2215
2216	/* OK. For now, we presume we have a valid client. We now create the
2217	client structure, even though we cannot fill it completely yet.
2218	But it allows us to access lm78_{read,write}_value. */
2219
2220	if (!(data = kmalloc(sizeof(struct lm93_data), GFP_KERNEL))) {
2221	pr_debug("lm93.o: detect failed, kmalloc failed!\n");
2222	err = -ENOMEM;
2223	goto ERROR0;
2224	}
2225
2226	client = &data->client;
2227	client->addr = address;
2228	client->data = data;
2229	client->adapter = adapter;
2230	client->driver = &lm93_driver;
2231	client->flags = 0;
2232
2233	/* detection */
2234	if (kind < 0) {
2235	int mfr = lm93_read_byte(client, LM93_REG_MFR_ID);
2236
2237	if (mfr != 0x01) {
2238	pr_debug("lm93.o: detect failed, "
2239	"bad manufacturer id 0x%02x!\n", mfr);
2240	goto ERROR1;
2241	}
2242	}
2243
2244	if (kind <= 0) {
2245	int ver = lm93_read_byte(client, LM93_REG_VER);
2246
2247	if ((ver == LM93_MFR_ID) \|\| (ver == LM93_MFR_ID_PROTOTYPE)) {
2248	kind = lm93;
2249	} else {
2250	pr_debug("lm93.o: detect failed, "
2251	"bad version id 0x%02x!\n", ver);
2252	if (kind == 0)
2253	pr_debug("lm93.o: "
2254	"(ignored 'force' parameter)\n");
2255	goto ERROR1;
2256	}
2257	}
2258
2259	/* fill in remaining client fields */
2260	strcpy(client->name, "LM93 chip");
2261	client->id = lm93_id++;
2262	pr_debug("lm93.o: assigning ID %d to %s at %d,0x%02x\n", client->id,
2263	client->name, i2c_adapter_id(client->adapter), client->addr);
2264
2265	/* housekeeping */
2266	data->valid = 0;
2267	data->update = update;
2268	init_MUTEX(&data->update_lock);
2269
2270	/* tell the I2C layer a new client has arrived */
2271	if ((err = i2c_attach_client(client)))
2272	goto ERROR1;
2273
2274	/* initialize the chip */
2275	lm93_init_client(client);
2276
2277	/* register a new directory entry with module sensors */
2278	if ((data->sysctl_id = i2c_register_entry(client, "lm93",
2279	lm93_dir_table_template, THIS_MODULE)) < 0) {
2280	err = data->sysctl_id;
2281	goto ERROR2;
2282	}
2283
2284	return 0;
2285
2286	ERROR2:
2287	i2c_detach_client(client);
2288	ERROR1:
2289	kfree(data);
2290	ERROR0:
2291	return err;
2292	}
2293
2294	/* This function is called when:
2295	* lm93_driver is inserted (when this module is loaded), for each
2296	available adapter
2297	* when a new adapter is inserted (and lm93_driver is still present) */
2298	static int lm93_attach_adapter(struct i2c_adapter *adapter)
2299	{
2300	return i2c_detect(adapter, &addr_data, lm93_detect);
2301	}
2302
2303	static int lm93_detach_client(struct i2c_client *client)
2304	{
2305	int err;
2306	struct lm93_data *data = client->data;
2307
2308	i2c_deregister_entry(data->sysctl_id);
2309
2310	if ((err = i2c_detach_client(client))) {
2311	printk (KERN_ERR "lm93.o: Client deregistration failed; "
2312	"client not detached.\n");
2313	return err;
2314	}
2315	kfree(data);
2316	return 0;
2317	}
2318
2319	static struct i2c_driver lm93_driver = {
2320	.name = "LM93 sensor driver",
2321	.id = I2C_DRIVERID_LM93,
2322	.flags = I2C_DF_NOTIFY,
2323	.attach_adapter = lm93_attach_adapter,
2324	.detach_client = lm93_detach_client,
2325	};
2326
2327	static int __init lm93_init(void)
2328	{
2329	printk(KERN_INFO "lm93.o version %s (%s)\n", LM_VERSION, LM_DATE);
2330	return i2c_add_driver(&lm93_driver);
2331	}
2332
2333	static void __exit lm93_exit(void)
2334	{
2335	i2c_del_driver(&lm93_driver);
2336	}
2337
2338	MODULE_AUTHOR("Mark M. Hoffman <mhoffman@lightlink.com>");
2339	MODULE_DESCRIPTION("LM93 driver");
2340	MODULE_LICENSE("GPL");
2341
2342	module_init(lm93_init);
2343	module_exit(lm93_exit);

Note: See TracBrowser for help on using the browser.

Context Navigation

root/lm-sensors/trunk/kernel/chips/lm93.c @ 4658

Download in other formats: