Blame view

kernel/linux-rt-4.4.41/drivers/hwmon/ultra45_env.c 8.32 KB
5113f6f70   김현기   kernel add
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
  /*
   * ultra45_env.c: Driver for Ultra45 PIC16F747 environmental monitor.
   *
   * Copyright (C) 2008 David S. Miller <davem@davemloft.net>
   */
  
  #include <linux/kernel.h>
  #include <linux/types.h>
  #include <linux/slab.h>
  #include <linux/module.h>
  #include <linux/of_device.h>
  #include <linux/io.h>
  #include <linux/hwmon.h>
  #include <linux/hwmon-sysfs.h>
  #include <linux/err.h>
  
  #define DRV_MODULE_VERSION	"0.1"
  
  MODULE_AUTHOR("David S. Miller (davem@davemloft.net)");
  MODULE_DESCRIPTION("Ultra45 environmental monitor driver");
  MODULE_LICENSE("GPL");
  MODULE_VERSION(DRV_MODULE_VERSION);
  
  /* PIC device registers */
  #define REG_CMD		0x00UL
  #define  REG_CMD_RESET	0x80
  #define  REG_CMD_ESTAR	0x01
  #define REG_STAT	0x01UL
  #define  REG_STAT_FWVER	0xf0
  #define  REG_STAT_TGOOD	0x08
  #define  REG_STAT_STALE	0x04
  #define  REG_STAT_BUSY	0x02
  #define  REG_STAT_FAULT	0x01
  #define REG_DATA	0x40UL
  #define REG_ADDR	0x41UL
  #define REG_SIZE	0x42UL
  
  /* Registers accessed indirectly via REG_DATA/REG_ADDR */
  #define IREG_FAN0		0x00
  #define IREG_FAN1		0x01
  #define IREG_FAN2		0x02
  #define IREG_FAN3		0x03
  #define IREG_FAN4		0x04
  #define IREG_FAN5		0x05
  #define IREG_LCL_TEMP		0x06
  #define IREG_RMT1_TEMP		0x07
  #define IREG_RMT2_TEMP		0x08
  #define IREG_RMT3_TEMP		0x09
  #define IREG_LM95221_TEMP	0x0a
  #define IREG_FIRE_TEMP		0x0b
  #define IREG_LSI1064_TEMP	0x0c
  #define IREG_FRONT_TEMP		0x0d
  #define IREG_FAN_STAT		0x0e
  #define IREG_VCORE0		0x0f
  #define IREG_VCORE1		0x10
  #define IREG_VMEM0		0x11
  #define IREG_VMEM1		0x12
  #define IREG_PSU_TEMP		0x13
  
  struct env {
  	void __iomem	*regs;
  	spinlock_t	lock;
  
  	struct device	*hwmon_dev;
  };
  
  static u8 env_read(struct env *p, u8 ireg)
  {
  	u8 ret;
  
  	spin_lock(&p->lock);
  	writeb(ireg, p->regs + REG_ADDR);
  	ret = readb(p->regs + REG_DATA);
  	spin_unlock(&p->lock);
  
  	return ret;
  }
  
  static void env_write(struct env *p, u8 ireg, u8 val)
  {
  	spin_lock(&p->lock);
  	writeb(ireg, p->regs + REG_ADDR);
  	writeb(val, p->regs + REG_DATA);
  	spin_unlock(&p->lock);
  }
  
  /*
   * There seems to be a adr7462 providing these values, thus a lot
   * of these calculations are borrowed from the adt7470 driver.
   */
  #define FAN_PERIOD_TO_RPM(x)	((90000 * 60) / (x))
  #define FAN_RPM_TO_PERIOD	FAN_PERIOD_TO_RPM
  #define FAN_PERIOD_INVALID	(0xff << 8)
  #define FAN_DATA_VALID(x)	((x) && (x) != FAN_PERIOD_INVALID)
  
  static ssize_t show_fan_speed(struct device *dev, struct device_attribute *attr,
  			      char *buf)
  {
  	int fan_nr = to_sensor_dev_attr(attr)->index;
  	struct env *p = dev_get_drvdata(dev);
  	int rpm, period;
  	u8 val;
  
  	val = env_read(p, IREG_FAN0 + fan_nr);
  	period = (int) val << 8;
  	if (FAN_DATA_VALID(period))
  		rpm = FAN_PERIOD_TO_RPM(period);
  	else
  		rpm = 0;
  
  	return sprintf(buf, "%d
  ", rpm);
  }
  
  static ssize_t set_fan_speed(struct device *dev, struct device_attribute *attr,
  			     const char *buf, size_t count)
  {
  	int fan_nr = to_sensor_dev_attr(attr)->index;
  	unsigned long rpm;
  	struct env *p = dev_get_drvdata(dev);
  	int period;
  	u8 val;
  	int err;
  
  	err = kstrtoul(buf, 10, &rpm);
  	if (err)
  		return err;
  
  	if (!rpm)
  		return -EINVAL;
  
  	period = FAN_RPM_TO_PERIOD(rpm);
  	val = period >> 8;
  	env_write(p, IREG_FAN0 + fan_nr, val);
  
  	return count;
  }
  
  static ssize_t show_fan_fault(struct device *dev, struct device_attribute *attr,
  			      char *buf)
  {
  	int fan_nr = to_sensor_dev_attr(attr)->index;
  	struct env *p = dev_get_drvdata(dev);
  	u8 val = env_read(p, IREG_FAN_STAT);
  	return sprintf(buf, "%d
  ", (val & (1 << fan_nr)) ? 1 : 0);
  }
  
  #define fan(index)							\
  static SENSOR_DEVICE_ATTR(fan##index##_speed, S_IRUGO | S_IWUSR,	\
  		show_fan_speed, set_fan_speed, index);			\
  static SENSOR_DEVICE_ATTR(fan##index##_fault, S_IRUGO,			\
  		show_fan_fault, NULL, index)
  
  fan(0);
  fan(1);
  fan(2);
  fan(3);
  fan(4);
  
  static SENSOR_DEVICE_ATTR(psu_fan_fault, S_IRUGO, show_fan_fault, NULL, 6);
  
  static ssize_t show_temp(struct device *dev, struct device_attribute *attr,
  			 char *buf)
  {
  	int temp_nr = to_sensor_dev_attr(attr)->index;
  	struct env *p = dev_get_drvdata(dev);
  	s8 val;
  
  	val = env_read(p, IREG_LCL_TEMP + temp_nr);
  	return sprintf(buf, "%d
  ", ((int) val) - 64);
  }
  
  static SENSOR_DEVICE_ATTR(adt7462_local_temp, S_IRUGO, show_temp, NULL, 0);
  static SENSOR_DEVICE_ATTR(cpu0_temp, S_IRUGO, show_temp, NULL, 1);
  static SENSOR_DEVICE_ATTR(cpu1_temp, S_IRUGO, show_temp, NULL, 2);
  static SENSOR_DEVICE_ATTR(motherboard_temp, S_IRUGO, show_temp, NULL, 3);
  static SENSOR_DEVICE_ATTR(lm95221_local_temp, S_IRUGO, show_temp, NULL, 4);
  static SENSOR_DEVICE_ATTR(fire_temp, S_IRUGO, show_temp, NULL, 5);
  static SENSOR_DEVICE_ATTR(lsi1064_local_temp, S_IRUGO, show_temp, NULL, 6);
  static SENSOR_DEVICE_ATTR(front_panel_temp, S_IRUGO, show_temp, NULL, 7);
  static SENSOR_DEVICE_ATTR(psu_temp, S_IRUGO, show_temp, NULL, 13);
  
  static ssize_t show_stat_bit(struct device *dev, struct device_attribute *attr,
  			     char *buf)
  {
  	int index = to_sensor_dev_attr(attr)->index;
  	struct env *p = dev_get_drvdata(dev);
  	u8 val;
  
  	val = readb(p->regs + REG_STAT);
  	return sprintf(buf, "%d
  ", (val & (1 << index)) ? 1 : 0);
  }
  
  static SENSOR_DEVICE_ATTR(fan_failure, S_IRUGO, show_stat_bit, NULL, 0);
  static SENSOR_DEVICE_ATTR(env_bus_busy, S_IRUGO, show_stat_bit, NULL, 1);
  static SENSOR_DEVICE_ATTR(env_data_stale, S_IRUGO, show_stat_bit, NULL, 2);
  static SENSOR_DEVICE_ATTR(tpm_self_test_passed, S_IRUGO, show_stat_bit, NULL,
  			  3);
  
  static ssize_t show_fwver(struct device *dev, struct device_attribute *attr,
  			  char *buf)
  {
  	struct env *p = dev_get_drvdata(dev);
  	u8 val;
  
  	val = readb(p->regs + REG_STAT);
  	return sprintf(buf, "%d
  ", val >> 4);
  }
  
  static SENSOR_DEVICE_ATTR(firmware_version, S_IRUGO, show_fwver, NULL, 0);
  
  static ssize_t show_name(struct device *dev, struct device_attribute *attr,
  			 char *buf)
  {
  	return sprintf(buf, "ultra45
  ");
  }
  
  static SENSOR_DEVICE_ATTR(name, S_IRUGO, show_name, NULL, 0);
  
  static struct attribute *env_attributes[] = {
  	&sensor_dev_attr_fan0_speed.dev_attr.attr,
  	&sensor_dev_attr_fan0_fault.dev_attr.attr,
  	&sensor_dev_attr_fan1_speed.dev_attr.attr,
  	&sensor_dev_attr_fan1_fault.dev_attr.attr,
  	&sensor_dev_attr_fan2_speed.dev_attr.attr,
  	&sensor_dev_attr_fan2_fault.dev_attr.attr,
  	&sensor_dev_attr_fan3_speed.dev_attr.attr,
  	&sensor_dev_attr_fan3_fault.dev_attr.attr,
  	&sensor_dev_attr_fan4_speed.dev_attr.attr,
  	&sensor_dev_attr_fan4_fault.dev_attr.attr,
  	&sensor_dev_attr_psu_fan_fault.dev_attr.attr,
  	&sensor_dev_attr_adt7462_local_temp.dev_attr.attr,
  	&sensor_dev_attr_cpu0_temp.dev_attr.attr,
  	&sensor_dev_attr_cpu1_temp.dev_attr.attr,
  	&sensor_dev_attr_motherboard_temp.dev_attr.attr,
  	&sensor_dev_attr_lm95221_local_temp.dev_attr.attr,
  	&sensor_dev_attr_fire_temp.dev_attr.attr,
  	&sensor_dev_attr_lsi1064_local_temp.dev_attr.attr,
  	&sensor_dev_attr_front_panel_temp.dev_attr.attr,
  	&sensor_dev_attr_psu_temp.dev_attr.attr,
  	&sensor_dev_attr_fan_failure.dev_attr.attr,
  	&sensor_dev_attr_env_bus_busy.dev_attr.attr,
  	&sensor_dev_attr_env_data_stale.dev_attr.attr,
  	&sensor_dev_attr_tpm_self_test_passed.dev_attr.attr,
  	&sensor_dev_attr_firmware_version.dev_attr.attr,
  	&sensor_dev_attr_name.dev_attr.attr,
  	NULL,
  };
  
  static const struct attribute_group env_group = {
  	.attrs = env_attributes,
  };
  
  static int env_probe(struct platform_device *op)
  {
  	struct env *p = devm_kzalloc(&op->dev, sizeof(*p), GFP_KERNEL);
  	int err = -ENOMEM;
  
  	if (!p)
  		goto out;
  
  	spin_lock_init(&p->lock);
  
  	p->regs = of_ioremap(&op->resource[0], 0, REG_SIZE, "pic16f747");
  	if (!p->regs)
  		goto out;
  
  	err = sysfs_create_group(&op->dev.kobj, &env_group);
  	if (err)
  		goto out_iounmap;
  
  	p->hwmon_dev = hwmon_device_register(&op->dev);
  	if (IS_ERR(p->hwmon_dev)) {
  		err = PTR_ERR(p->hwmon_dev);
  		goto out_sysfs_remove_group;
  	}
  
  	platform_set_drvdata(op, p);
  	err = 0;
  
  out:
  	return err;
  
  out_sysfs_remove_group:
  	sysfs_remove_group(&op->dev.kobj, &env_group);
  
  out_iounmap:
  	of_iounmap(&op->resource[0], p->regs, REG_SIZE);
  
  	goto out;
  }
  
  static int env_remove(struct platform_device *op)
  {
  	struct env *p = platform_get_drvdata(op);
  
  	if (p) {
  		sysfs_remove_group(&op->dev.kobj, &env_group);
  		hwmon_device_unregister(p->hwmon_dev);
  		of_iounmap(&op->resource[0], p->regs, REG_SIZE);
  	}
  
  	return 0;
  }
  
  static const struct of_device_id env_match[] = {
  	{
  		.name = "env-monitor",
  		.compatible = "SUNW,ebus-pic16f747-env",
  	},
  	{},
  };
  MODULE_DEVICE_TABLE(of, env_match);
  
  static struct platform_driver env_driver = {
  	.driver = {
  		.name = "ultra45_env",
  		.of_match_table = env_match,
  	},
  	.probe		= env_probe,
  	.remove		= env_remove,
  };
  
  module_platform_driver(env_driver);