projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
usermodehelper: split setup from execution
[deliverable/linux.git] / drivers / sbus / char / envctrl.c
CommitLineData
1da177e4
LT		 1/* $Id: envctrl.c,v 1.25 2002/01/15 09:01:26 davem Exp $
2 * envctrl.c: Temperature and Fan monitoring on Machines providing it.
3 *
4 * Copyright (C) 1998 Eddie C. Dost (ecd@skynet.be)
5 * Copyright (C) 2000 Vinh Truong (vinh.truong@eng.sun.com)
6 * VT - The implementation is to support Sun Microelectronics (SME) platform
7 * environment monitoring. SME platforms use pcf8584 as the i2c bus
8 * controller to access pcf8591 (8-bit A/D and D/A converter) and
9 * pcf8571 (256 x 8-bit static low-voltage RAM with I2C-bus interface).
10 * At board level, it follows SME Firmware I2C Specification. Reference:
11 * http://www-eu2.semiconductors.com/pip/PCF8584P
12 * http://www-eu2.semiconductors.com/pip/PCF8574AP
13 * http://www-eu2.semiconductors.com/pip/PCF8591P
14 *
15 * EB - Added support for CP1500 Global Address and PS/Voltage monitoring.
16 * Eric Brower <ebrower@usa.net>
17 *
18 * DB - Audit every copy_to_user in envctrl_read.
19 * Daniele Bellucci <bellucda@tiscali.it>
20 */
21
1da177e4 22#include <linux/module.h>
1baaf0b4 23#include <linux/init.h>
218b29e0 24#include <linux/kthread.h>
1da177e4
LT		 25#include <linux/delay.h>
26#include <linux/ioport.h>
1da177e4 27#include <linux/miscdevice.h>
872ec648 28#include <linux/kmod.h>
1da177e4
LT		 29
30#include <asm/ebus.h>
31#include <asm/uaccess.h>
32#include <asm/envctrl.h>
e1a39fbb 33#include <asm/io.h>
1da177e4 34
1da177e4
LT		 35#define ENVCTRL_MINOR 162
36
37#define PCF8584_ADDRESS 0x55
38
39#define CONTROL_PIN 0x80
40#define CONTROL_ES0 0x40
41#define CONTROL_ES1 0x20
42#define CONTROL_ES2 0x10
43#define CONTROL_ENI 0x08
44#define CONTROL_STA 0x04
45#define CONTROL_STO 0x02
46#define CONTROL_ACK 0x01
47
48#define STATUS_PIN 0x80
49#define STATUS_STS 0x20
50#define STATUS_BER 0x10
51#define STATUS_LRB 0x08
52#define STATUS_AD0 0x08
53#define STATUS_AAB 0x04
54#define STATUS_LAB 0x02
55#define STATUS_BB 0x01
56
57/*
58 * CLK Mode Register.
59 */
60#define BUS_CLK_90 0x00
61#define BUS_CLK_45 0x01
62#define BUS_CLK_11 0x02
63#define BUS_CLK_1_5 0x03
64
65#define CLK_3 0x00
66#define CLK_4_43 0x10
67#define CLK_6 0x14
68#define CLK_8 0x18
69#define CLK_12 0x1c
70
71#define OBD_SEND_START 0xc5 /* value to generate I2c_bus START condition */
72#define OBD_SEND_STOP 0xc3 /* value to generate I2c_bus STOP condition */
73
74/* Monitor type of i2c child device.
75 * Firmware definitions.
76 */
77#define PCF8584_MAX_CHANNELS 8
78#define PCF8584_GLOBALADDR_TYPE 6 /* global address monitor */
79#define PCF8584_FANSTAT_TYPE 3 /* fan status monitor */
80#define PCF8584_VOLTAGE_TYPE 2 /* voltage monitor */
81#define PCF8584_TEMP_TYPE 1 /* temperature monitor*/
82
83/* Monitor type of i2c child device.
84 * Driver definitions.
85 */
86#define ENVCTRL_NOMON 0
87#define ENVCTRL_CPUTEMP_MON 1 /* cpu temperature monitor */
88#define ENVCTRL_CPUVOLTAGE_MON 2 /* voltage monitor */
89#define ENVCTRL_FANSTAT_MON 3 /* fan status monitor */
90#define ENVCTRL_ETHERTEMP_MON 4 /* ethernet temperarture */
91 /* monitor */
92#define ENVCTRL_VOLTAGESTAT_MON 5 /* voltage status monitor */
93#define ENVCTRL_MTHRBDTEMP_MON 6 /* motherboard temperature */
94#define ENVCTRL_SCSITEMP_MON 7 /* scsi temperarture */
95#define ENVCTRL_GLOBALADDR_MON 8 /* global address */
96
97/* Child device type.
98 * Driver definitions.
99 */
100#define I2C_ADC 0 /* pcf8591 */
101#define I2C_GPIO 1 /* pcf8571 */
102
103/* Data read from child device may need to decode
104 * through a data table and a scale.
105 * Translation type as defined by firmware.
106 */
107#define ENVCTRL_TRANSLATE_NO 0
108#define ENVCTRL_TRANSLATE_PARTIAL 1
109#define ENVCTRL_TRANSLATE_COMBINED 2
110#define ENVCTRL_TRANSLATE_FULL 3 /* table[data] */
111#define ENVCTRL_TRANSLATE_SCALE 4 /* table[data]/scale */
112
113/* Driver miscellaneous definitions. */
114#define ENVCTRL_MAX_CPU 4
115#define CHANNEL_DESC_SZ 256
116
117/* Mask values for combined GlobalAddress/PowerStatus node */
118#define ENVCTRL_GLOBALADDR_ADDR_MASK 0x1F
119#define ENVCTRL_GLOBALADDR_PSTAT_MASK 0x60
120
121/* Node 0x70 ignored on CompactPCI CP1400/1500 platforms
122 * (see envctrl_init_i2c_child)
123 */
124#define ENVCTRL_CPCI_IGNORED_NODE 0x70
125
126#define PCF8584_DATA 0x00
127#define PCF8584_CSR 0x01
128
129/* Each child device can be monitored by up to PCF8584_MAX_CHANNELS.
130 * Property of a port or channel as defined by the firmware.
131 */
132struct pcf8584_channel {
133 unsigned char chnl_no;
134 unsigned char io_direction;
135 unsigned char type;
136 unsigned char last;
137};
138
139/* Each child device may have one or more tables of bytes to help decode
140 * data. Table property as defined by the firmware.
141 */
142struct pcf8584_tblprop {
143 unsigned int type;
144 unsigned int scale;
145 unsigned int offset; /* offset from the beginning of the table */
146 unsigned int size;
147};
148
149/* i2c child */
150struct i2c_child_t {
151 /* Either ADC or GPIO. */
152 unsigned char i2ctype;
153 unsigned long addr;
154 struct pcf8584_channel chnl_array[PCF8584_MAX_CHANNELS];
155
156 /* Channel info. */
157 unsigned int total_chnls; /* Number of monitor channels. */
158 unsigned char fan_mask; /* Byte mask for fan status channels. */
159 unsigned char voltage_mask; /* Byte mask for voltage status channels. */
160 struct pcf8584_tblprop tblprop_array[PCF8584_MAX_CHANNELS];
161
162 /* Properties of all monitor channels. */
163 unsigned int total_tbls; /* Number of monitor tables. */
164 char *tables; /* Pointer to table(s). */
165 char chnls_desc[CHANNEL_DESC_SZ]; /* Channel description. */
166 char mon_type[PCF8584_MAX_CHANNELS];
167};
168
169static void __iomem *i2c;
170static struct i2c_child_t i2c_childlist[ENVCTRL_MAX_CPU*2];
171static unsigned char chnls_mask[] = { 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80 };
172static unsigned int warning_temperature = 0;
173static unsigned int shutdown_temperature = 0;
174static char read_cpu;
175
176/* Forward declarations. */
177static struct i2c_child_t *envctrl_get_i2c_child(unsigned char);
178
179/* Function Description: Test the PIN bit (Pending Interrupt Not)
180 * to test when serial transmission is completed .
181 * Return : None.
182 */
183static void envtrl_i2c_test_pin(void)
184{
185 int limit = 1000000;
186
187 while (--limit > 0) {
188 if (!(readb(i2c + PCF8584_CSR) & STATUS_PIN))
189 break;
190 udelay(1);
191 }
192
193 if (limit <= 0)
194 printk(KERN_INFO "envctrl: Pin status will not clear.\n");
195}
196
197/* Function Description: Test busy bit.
198 * Return : None.
199 */
200static void envctrl_i2c_test_bb(void)
201{
202 int limit = 1000000;
203
204 while (--limit > 0) {
205 /* Busy bit 0 means busy. */
206 if (readb(i2c + PCF8584_CSR) & STATUS_BB)
207 break;
208 udelay(1);
209 }
210
211 if (limit <= 0)
212 printk(KERN_INFO "envctrl: Busy bit will not clear.\n");
213}
214
215/* Function Description: Send the address for a read access.
216 * Return : 0 if not acknowledged, otherwise acknowledged.
217 */
218static int envctrl_i2c_read_addr(unsigned char addr)
219{
220 envctrl_i2c_test_bb();
221
222 /* Load address. */
223 writeb(addr + 1, i2c + PCF8584_DATA);
224
225 envctrl_i2c_test_bb();
226
227 writeb(OBD_SEND_START, i2c + PCF8584_CSR);
228
229 /* Wait for PIN. */
230 envtrl_i2c_test_pin();
231
232 /* CSR 0 means acknowledged. */
233 if (!(readb(i2c + PCF8584_CSR) & STATUS_LRB)) {
234 return readb(i2c + PCF8584_DATA);
235 } else {
236 writeb(OBD_SEND_STOP, i2c + PCF8584_CSR);
237 return 0;
238 }
239}
240
241/* Function Description: Send the address for write mode.
242 * Return : None.
243 */
244static void envctrl_i2c_write_addr(unsigned char addr)
245{
246 envctrl_i2c_test_bb();
247 writeb(addr, i2c + PCF8584_DATA);
248
249 /* Generate Start condition. */
250 writeb(OBD_SEND_START, i2c + PCF8584_CSR);
251}
252
253/* Function Description: Read 1 byte of data from addr
254 * set by envctrl_i2c_read_addr()
255 * Return : Data from address set by envctrl_i2c_read_addr().
256 */
257static unsigned char envctrl_i2c_read_data(void)
258{
259 envtrl_i2c_test_pin();
260 writeb(CONTROL_ES0, i2c + PCF8584_CSR); /* Send neg ack. */
261 return readb(i2c + PCF8584_DATA);
262}
263
264/* Function Description: Instruct the device which port to read data from.
265 * Return : None.
266 */
267static void envctrl_i2c_write_data(unsigned char port)
268{
269 envtrl_i2c_test_pin();
270 writeb(port, i2c + PCF8584_DATA);
271}
272
273/* Function Description: Generate Stop condition after last byte is sent.
274 * Return : None.
275 */
276static void envctrl_i2c_stop(void)
277{
278 envtrl_i2c_test_pin();
279 writeb(OBD_SEND_STOP, i2c + PCF8584_CSR);
280}
281
282/* Function Description: Read adc device.
283 * Return : Data at address and port.
284 */
285static unsigned char envctrl_i2c_read_8591(unsigned char addr, unsigned char port)
286{
287 /* Send address. */
288 envctrl_i2c_write_addr(addr);
289
290 /* Setup port to read. */
291 envctrl_i2c_write_data(port);
292 envctrl_i2c_stop();
293
294 /* Read port. */
295 envctrl_i2c_read_addr(addr);
296
297 /* Do a single byte read and send stop. */
298 envctrl_i2c_read_data();
299 envctrl_i2c_stop();
300
301 return readb(i2c + PCF8584_DATA);
302}
303
304/* Function Description: Read gpio device.
305 * Return : Data at address.
306 */
307static unsigned char envctrl_i2c_read_8574(unsigned char addr)
308{
309 unsigned char rd;
310
311 envctrl_i2c_read_addr(addr);
312
313 /* Do a single byte read and send stop. */
314 rd = envctrl_i2c_read_data();
315 envctrl_i2c_stop();
316 return rd;
317}
318
319/* Function Description: Decode data read from an adc device using firmware
320 * table.
321 * Return: Number of read bytes. Data is stored in bufdata in ascii format.
322 */
323static int envctrl_i2c_data_translate(unsigned char data, int translate_type,
324 int scale, char *tbl, char *bufdata)
325{
326 int len = 0;
327
328 switch (translate_type) {
329 case ENVCTRL_TRANSLATE_NO:
330 /* No decode necessary. */
331 len = 1;
332 bufdata[0] = data;
333 break;
334
335 case ENVCTRL_TRANSLATE_FULL:
336 /* Decode this way: data = table[data]. */
337 len = 1;
338 bufdata[0] = tbl[data];
339 break;
340
341 case ENVCTRL_TRANSLATE_SCALE:
342 /* Decode this way: data = table[data]/scale */
343 sprintf(bufdata,"%d ", (tbl[data] * 10) / (scale));
344 len = strlen(bufdata);
345 bufdata[len - 1] = bufdata[len - 2];
346 bufdata[len - 2] = '.';
347 break;
348
349 default:
350 break;
351 };
352
353 return len;
354}
355
356/* Function Description: Read cpu-related data such as cpu temperature, voltage.
357 * Return: Number of read bytes. Data is stored in bufdata in ascii format.
358 */
359static int envctrl_read_cpu_info(int cpu, struct i2c_child_t *pchild,
360 char mon_type, unsigned char *bufdata)
361{
362 unsigned char data;
363 int i;
364 char *tbl, j = -1;
365
366 /* Find the right monitor type and channel. */
367 for (i = 0; i < PCF8584_MAX_CHANNELS; i++) {
368 if (pchild->mon_type[i] == mon_type) {
369 if (++j == cpu) {
370 break;
371 }
372 }
373 }
374
375 if (j != cpu)
376 return 0;
377
378 /* Read data from address and port. */
379 data = envctrl_i2c_read_8591((unsigned char)pchild->addr,
380 (unsigned char)pchild->chnl_array[i].chnl_no);
381
382 /* Find decoding table. */
383 tbl = pchild->tables + pchild->tblprop_array[i].offset;
384
385 return envctrl_i2c_data_translate(data, pchild->tblprop_array[i].type,
386 pchild->tblprop_array[i].scale,
387 tbl, bufdata);
388}
389
390/* Function Description: Read noncpu-related data such as motherboard
391 * temperature.
392 * Return: Number of read bytes. Data is stored in bufdata in ascii format.
393 */
394static int envctrl_read_noncpu_info(struct i2c_child_t *pchild,
395 char mon_type, unsigned char *bufdata)
396{
397 unsigned char data;
398 int i;
399 char *tbl = NULL;
400
401 for (i = 0; i < PCF8584_MAX_CHANNELS; i++) {
402 if (pchild->mon_type[i] == mon_type)
403 break;
404 }
405
406 if (i >= PCF8584_MAX_CHANNELS)
407 return 0;
408
409 /* Read data from address and port. */
410 data = envctrl_i2c_read_8591((unsigned char)pchild->addr,
411 (unsigned char)pchild->chnl_array[i].chnl_no);
412
413 /* Find decoding table. */
414 tbl = pchild->tables + pchild->tblprop_array[i].offset;
415
416 return envctrl_i2c_data_translate(data, pchild->tblprop_array[i].type,
417 pchild->tblprop_array[i].scale,
418 tbl, bufdata);
419}
420
421/* Function Description: Read fan status.
422 * Return : Always 1 byte. Status stored in bufdata.
423 */
424static int envctrl_i2c_fan_status(struct i2c_child_t *pchild,
425 unsigned char data,
426 char *bufdata)
427{
428 unsigned char tmp, ret = 0;
429 int i, j = 0;
430
431 tmp = data & pchild->fan_mask;
432
433 if (tmp == pchild->fan_mask) {
434 /* All bits are on. All fans are functioning. */
435 ret = ENVCTRL_ALL_FANS_GOOD;
436 } else if (tmp == 0) {
437 /* No bits are on. No fans are functioning. */
438 ret = ENVCTRL_ALL_FANS_BAD;
439 } else {
440 /* Go through all channels, mark 'on' the matched bits.
441 * Notice that fan_mask may have discontiguous bits but
442 * return mask are always contiguous. For example if we
443 * monitor 4 fans at channels 0,1,2,4, the return mask
444 * should be 00010000 if only fan at channel 4 is working.
445 */
446 for (i = 0; i < PCF8584_MAX_CHANNELS;i++) {
447 if (pchild->fan_mask & chnls_mask[i]) {
448 if (!(chnls_mask[i] & tmp))
449 ret |= chnls_mask[j];
450
451 j++;
452 }
453 }
454 }
455
456 bufdata[0] = ret;
457 return 1;
458}
459
460/* Function Description: Read global addressing line.
461 * Return : Always 1 byte. Status stored in bufdata.
462 */
463static int envctrl_i2c_globaladdr(struct i2c_child_t *pchild,
464 unsigned char data,
465 char *bufdata)
466{
467 /* Translatation table is not necessary, as global
468 * addr is the integer value of the GA# bits.
469 *
470 * NOTE: MSB is documented as zero, but I see it as '1' always....
471 *
472 * -----------------------------------------------
473 * | 0 | FAL | DEG | GA4 | GA3 | GA2 | GA1 | GA0 |
474 * -----------------------------------------------
475 * GA0 - GA4 integer value of Global Address (backplane slot#)
476 * DEG 0 = cPCI Power supply output is starting to degrade
477 * 1 = cPCI Power supply output is OK
478 * FAL 0 = cPCI Power supply has failed
479 * 1 = cPCI Power supply output is OK
480 */
481 bufdata[0] = (data & ENVCTRL_GLOBALADDR_ADDR_MASK);
482 return 1;
483}
484
485/* Function Description: Read standard voltage and power supply status.
486 * Return : Always 1 byte. Status stored in bufdata.
487 */
488static unsigned char envctrl_i2c_voltage_status(struct i2c_child_t *pchild,
489 unsigned char data,
490 char *bufdata)
491{
492 unsigned char tmp, ret = 0;
493 int i, j = 0;
494
495 tmp = data & pchild->voltage_mask;
496
497 /* Two channels are used to monitor voltage and power supply. */
498 if (tmp == pchild->voltage_mask) {
499 /* All bits are on. Voltage and power supply are okay. */
500 ret = ENVCTRL_VOLTAGE_POWERSUPPLY_GOOD;
501 } else if (tmp == 0) {
502 /* All bits are off. Voltage and power supply are bad */
503 ret = ENVCTRL_VOLTAGE_POWERSUPPLY_BAD;
504 } else {
505 /* Either voltage or power supply has problem. */
506 for (i = 0; i < PCF8584_MAX_CHANNELS; i++) {
507 if (pchild->voltage_mask & chnls_mask[i]) {
508 j++;
509
510 /* Break out when there is a mismatch. */
511 if (!(chnls_mask[i] & tmp))
512 break;
513 }
514 }
515
516 /* Make a wish that hardware will always use the
517 * first channel for voltage and the second for
518 * power supply.
519 */
520 if (j == 1)
521 ret = ENVCTRL_VOLTAGE_BAD;
522 else
523 ret = ENVCTRL_POWERSUPPLY_BAD;
524 }
525
526 bufdata[0] = ret;
527 return 1;
528}
529
530/* Function Description: Read a byte from /dev/envctrl. Mapped to user read().
531 * Return: Number of read bytes. 0 for error.
532 */
533static ssize_t
534envctrl_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
535{
536 struct i2c_child_t *pchild;
537 unsigned char data[10];
538 int ret = 0;
539
540 /* Get the type of read as decided in ioctl() call.
541 * Find the appropriate i2c child.
542 * Get the data and put back to the user buffer.
543 */
544
545 switch ((int)(long)file->private_data) {
546 case ENVCTRL_RD_WARNING_TEMPERATURE:
547 if (warning_temperature == 0)
548 return 0;
549
550 data[0] = (unsigned char)(warning_temperature);
551 ret = 1;
552 if (copy_to_user(buf, data, ret))
553 ret = -EFAULT;
554 break;
555
556 case ENVCTRL_RD_SHUTDOWN_TEMPERATURE:
557 if (shutdown_temperature == 0)
558 return 0;
559
560 data[0] = (unsigned char)(shutdown_temperature);
561 ret = 1;
562 if (copy_to_user(buf, data, ret))
563 ret = -EFAULT;
564 break;
565
566 case ENVCTRL_RD_MTHRBD_TEMPERATURE:
567 if (!(pchild = envctrl_get_i2c_child(ENVCTRL_MTHRBDTEMP_MON)))
568 return 0;
569 ret = envctrl_read_noncpu_info(pchild, ENVCTRL_MTHRBDTEMP_MON, data);
570 if (copy_to_user(buf, data, ret))
571 ret = -EFAULT;
572 break;
573
574 case ENVCTRL_RD_CPU_TEMPERATURE:
575 if (!(pchild = envctrl_get_i2c_child(ENVCTRL_CPUTEMP_MON)))
576 return 0;
577 ret = envctrl_read_cpu_info(read_cpu, pchild, ENVCTRL_CPUTEMP_MON, data);
578
579 /* Reset cpu to the default cpu0. */
580 if (copy_to_user(buf, data, ret))
581 ret = -EFAULT;
582 break;
583
584 case ENVCTRL_RD_CPU_VOLTAGE:
585 if (!(pchild = envctrl_get_i2c_child(ENVCTRL_CPUVOLTAGE_MON)))
586 return 0;
587 ret = envctrl_read_cpu_info(read_cpu, pchild, ENVCTRL_CPUVOLTAGE_MON, data);
588
589 /* Reset cpu to the default cpu0. */
590 if (copy_to_user(buf, data, ret))
591 ret = -EFAULT;
592 break;
593
594 case ENVCTRL_RD_SCSI_TEMPERATURE:
595 if (!(pchild = envctrl_get_i2c_child(ENVCTRL_SCSITEMP_MON)))
596 return 0;
597 ret = envctrl_read_noncpu_info(pchild, ENVCTRL_SCSITEMP_MON, data);
598 if (copy_to_user(buf, data, ret))
599 ret = -EFAULT;
600 break;
601
602 case ENVCTRL_RD_ETHERNET_TEMPERATURE:
603 if (!(pchild = envctrl_get_i2c_child(ENVCTRL_ETHERTEMP_MON)))
604 return 0;
605 ret = envctrl_read_noncpu_info(pchild, ENVCTRL_ETHERTEMP_MON, data);
606 if (copy_to_user(buf, data, ret))
607 ret = -EFAULT;
608 break;
609
610 case ENVCTRL_RD_FAN_STATUS:
611 if (!(pchild = envctrl_get_i2c_child(ENVCTRL_FANSTAT_MON)))
612 return 0;
613 data[0] = envctrl_i2c_read_8574(pchild->addr);
614 ret = envctrl_i2c_fan_status(pchild,data[0], data);
615 if (copy_to_user(buf, data, ret))
616 ret = -EFAULT;
617 break;
618
619 case ENVCTRL_RD_GLOBALADDRESS:
620 if (!(pchild = envctrl_get_i2c_child(ENVCTRL_GLOBALADDR_MON)))
621 return 0;
622 data[0] = envctrl_i2c_read_8574(pchild->addr);
623 ret = envctrl_i2c_globaladdr(pchild, data[0], data);
624 if (copy_to_user(buf, data, ret))
625 ret = -EFAULT;
626 break;
627
628 case ENVCTRL_RD_VOLTAGE_STATUS:
629 if (!(pchild = envctrl_get_i2c_child(ENVCTRL_VOLTAGESTAT_MON)))
630 /* If voltage monitor not present, check for CPCI equivalent */
631 if (!(pchild = envctrl_get_i2c_child(ENVCTRL_GLOBALADDR_MON)))
632 return 0;
633 data[0] = envctrl_i2c_read_8574(pchild->addr);
634 ret = envctrl_i2c_voltage_status(pchild, data[0], data);
635 if (copy_to_user(buf, data, ret))
636 ret = -EFAULT;
637 break;
638
639 default:
640 break;
641
642 };
643
644 return ret;
645}
646
647/* Function Description: Command what to read. Mapped to user ioctl().
648 * Return: Gives 0 for implemented commands, -EINVAL otherwise.
649 */
1928f8e5
CH		 650static long
651envctrl_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
1da177e4
LT		 652{
653 char __user *infobuf;
654
655 switch (cmd) {
656 case ENVCTRL_RD_WARNING_TEMPERATURE:
657 case ENVCTRL_RD_SHUTDOWN_TEMPERATURE:
658 case ENVCTRL_RD_MTHRBD_TEMPERATURE:
659 case ENVCTRL_RD_FAN_STATUS:
660 case ENVCTRL_RD_VOLTAGE_STATUS:
661 case ENVCTRL_RD_ETHERNET_TEMPERATURE:
662 case ENVCTRL_RD_SCSI_TEMPERATURE:
663 case ENVCTRL_RD_GLOBALADDRESS:
664 file->private_data = (void *)(long)cmd;
665 break;
666
667 case ENVCTRL_RD_CPU_TEMPERATURE:
668 case ENVCTRL_RD_CPU_VOLTAGE:
669 /* Check to see if application passes in any cpu number,
670 * the default is cpu0.
671 */
672 infobuf = (char __user *) arg;
673 if (infobuf == NULL) {
674 read_cpu = 0;
675 }else {
676 get_user(read_cpu, infobuf);
677 }
678
679 /* Save the command for use when reading. */
680 file->private_data = (void *)(long)cmd;
681 break;
682
683 default:
684 return -EINVAL;
685 };
686
687 return 0;
688}
689
690/* Function Description: open device. Mapped to user open().
691 * Return: Always 0.
692 */
693static int
694envctrl_open(struct inode *inode, struct file *file)
695{
696 file->private_data = NULL;
697 return 0;
698}
699
700/* Function Description: Open device. Mapped to user close().
701 * Return: Always 0.
702 */
703static int
704envctrl_release(struct inode *inode, struct file *file)
705{
706 return 0;
707}
708
00977a59 709static const struct file_operations envctrl_fops = {
1928f8e5
CH		 710 .owner = THIS_MODULE,
711 .read = envctrl_read,
712 .unlocked_ioctl = envctrl_ioctl,
713#ifdef CONFIG_COMPAT
714 .compat_ioctl = envctrl_ioctl,
715#endif
716 .open = envctrl_open,
717 .release = envctrl_release,
1da177e4
LT		 718};
719
720static struct miscdevice envctrl_dev = {
721 ENVCTRL_MINOR,
722 "envctrl",
723 &envctrl_fops
724};
725
726/* Function Description: Set monitor type based on firmware description.
727 * Return: None.
728 */
729static void envctrl_set_mon(struct i2c_child_t *pchild,
ccf0dec6 730 const char *chnl_desc,
1da177e4
LT		 731 int chnl_no)
732{
733 /* Firmware only has temperature type. It does not distinguish
734 * different kinds of temperatures. We use channel description
735 * to disinguish them.
736 */
737 if (!(strcmp(chnl_desc,"temp,cpu")) ||
738 !(strcmp(chnl_desc,"temp,cpu0")) ||
739 !(strcmp(chnl_desc,"temp,cpu1")) ||
740 !(strcmp(chnl_desc,"temp,cpu2")) ||
741 !(strcmp(chnl_desc,"temp,cpu3")))
742 pchild->mon_type[chnl_no] = ENVCTRL_CPUTEMP_MON;
743
744 if (!(strcmp(chnl_desc,"vddcore,cpu0")) ||
745 !(strcmp(chnl_desc,"vddcore,cpu1")) ||
746 !(strcmp(chnl_desc,"vddcore,cpu2")) ||
747 !(strcmp(chnl_desc,"vddcore,cpu3")))
748 pchild->mon_type[chnl_no] = ENVCTRL_CPUVOLTAGE_MON;
749
750 if (!(strcmp(chnl_desc,"temp,motherboard")))
751 pchild->mon_type[chnl_no] = ENVCTRL_MTHRBDTEMP_MON;
752
753 if (!(strcmp(chnl_desc,"temp,scsi")))
754 pchild->mon_type[chnl_no] = ENVCTRL_SCSITEMP_MON;
755
756 if (!(strcmp(chnl_desc,"temp,ethernet")))
757 pchild->mon_type[chnl_no] = ENVCTRL_ETHERTEMP_MON;
758}
759
760/* Function Description: Initialize monitor channel with channel desc,
761 * decoding tables, monitor type, optional properties.
762 * Return: None.
763 */
690c8fd3 764static void envctrl_init_adc(struct i2c_child_t *pchild, struct device_node *dp)
1da177e4 765{
1da177e4 766 int i = 0, len;
ccf0dec6
SR		 767 const char *pos;
768 const unsigned int *pval;
1da177e4
LT		 769
770 /* Firmware describe channels into a stream separated by a '\0'. */
690c8fd3 771 pos = of_get_property(dp, "channels-description", &len);
1da177e4
LT		 772
773 while (len > 0) {
774 int l = strlen(pos) + 1;
775 envctrl_set_mon(pchild, pos, i++);
776 len -= l;
777 pos += l;
778 }
779
780 /* Get optional properties. */
690c8fd3
DM		 781 pval = of_get_property(dp, "warning-temp", NULL);
782 if (pval)
783 warning_temperature = *pval;
784
785 pval = of_get_property(dp, "shutdown-temp", NULL);
786 if (pval)
787 shutdown_temperature = *pval;
1da177e4
LT		 788}
789
790/* Function Description: Initialize child device monitoring fan status.
791 * Return: None.
792 */
793static void envctrl_init_fanstat(struct i2c_child_t *pchild)
794{
795 int i;
796
797 /* Go through all channels and set up the mask. */
798 for (i = 0; i < pchild->total_chnls; i++)
799 pchild->fan_mask |= chnls_mask[(pchild->chnl_array[i]).chnl_no];
800
801 /* We only need to know if this child has fan status monitored.
802 * We don't care which channels since we have the mask already.
803 */
804 pchild->mon_type[0] = ENVCTRL_FANSTAT_MON;
805}
806
807/* Function Description: Initialize child device for global addressing line.
808 * Return: None.
809 */
810static void envctrl_init_globaladdr(struct i2c_child_t *pchild)
811{
812 int i;
813
814 /* Voltage/PowerSupply monitoring is piggybacked
815 * with Global Address on CompactPCI. See comments
816 * within envctrl_i2c_globaladdr for bit assignments.
817 *
818 * The mask is created here by assigning mask bits to each
819 * bit position that represents PCF8584_VOLTAGE_TYPE data.
820 * Channel numbers are not consecutive within the globaladdr
821 * node (why?), so we use the actual counter value as chnls_mask
822 * index instead of the chnl_array[x].chnl_no value.
823 *
824 * NOTE: This loop could be replaced with a constant representing
825 * a mask of bits 5&6 (ENVCTRL_GLOBALADDR_PSTAT_MASK).
826 */
827 for (i = 0; i < pchild->total_chnls; i++) {
828 if (PCF8584_VOLTAGE_TYPE == pchild->chnl_array[i].type) {
829 pchild->voltage_mask |= chnls_mask[i];
830 }
831 }
832
833 /* We only need to know if this child has global addressing
834 * line monitored. We don't care which channels since we know
835 * the mask already (ENVCTRL_GLOBALADDR_ADDR_MASK).
836 */
837 pchild->mon_type[0] = ENVCTRL_GLOBALADDR_MON;
838}
839
840/* Initialize child device monitoring voltage status. */
841static void envctrl_init_voltage_status(struct i2c_child_t *pchild)
842{
843 int i;
844
845 /* Go through all channels and set up the mask. */
846 for (i = 0; i < pchild->total_chnls; i++)
847 pchild->voltage_mask |= chnls_mask[(pchild->chnl_array[i]).chnl_no];
848
849 /* We only need to know if this child has voltage status monitored.
850 * We don't care which channels since we have the mask already.
851 */
852 pchild->mon_type[0] = ENVCTRL_VOLTAGESTAT_MON;
853}
854
855/* Function Description: Initialize i2c child device.
856 * Return: None.
857 */
858static void envctrl_init_i2c_child(struct linux_ebus_child *edev_child,
859 struct i2c_child_t *pchild)
860{
690c8fd3
DM		 861 int len, i, tbls_size = 0;
862 struct device_node *dp = edev_child->prom_node;
ccf0dec6 863 const void *pval;
1da177e4
LT		 864
865 /* Get device address. */
690c8fd3
DM		 866 pval = of_get_property(dp, "reg", &len);
867 memcpy(&pchild->addr, pval, len);
1da177e4
LT		 868
869 /* Get tables property. Read firmware temperature tables. */
690c8fd3
DM		 870 pval = of_get_property(dp, "translation", &len);
871 if (pval && len > 0) {
872 memcpy(pchild->tblprop_array, pval, len);
1da177e4
LT		 873 pchild->total_tbls = len / sizeof(struct pcf8584_tblprop);
874 for (i = 0; i < pchild->total_tbls; i++) {
875 if ((pchild->tblprop_array[i].size + pchild->tblprop_array[i].offset) > tbls_size) {
876 tbls_size = pchild->tblprop_array[i].size + pchild->tblprop_array[i].offset;
877 }
878 }
879
880 pchild->tables = kmalloc(tbls_size, GFP_KERNEL);
881 if (pchild->tables == NULL){
882 printk("envctrl: Failed to allocate table.\n");
883 return;
884 }
690c8fd3
DM		 885 pval = of_get_property(dp, "tables", &len);
886 if (!pval || len <= 0) {
1da177e4
LT		 887 printk("envctrl: Failed to get table.\n");
888 return;
889 }
690c8fd3 890 memcpy(pchild->tables, pval, len);
1da177e4
LT		 891 }
892
893 /* SPARCengine ASM Reference Manual (ref. SMI doc 805-7581-04)
894 * sections 2.5, 3.5, 4.5 state node 0x70 for CP1400/1500 is
895 * "For Factory Use Only."
896 *
897 * We ignore the node on these platforms by assigning the
898 * 'NULL' monitor type.
899 */
900 if (ENVCTRL_CPCI_IGNORED_NODE == pchild->addr) {
690c8fd3 901 struct device_node *root_node;
1da177e4 902 int len;
1da177e4 903
690c8fd3
DM		 904 root_node = of_find_node_by_path("/");
905 if (!strcmp(root_node->name, "SUNW,UltraSPARC-IIi-cEngine")) {
1da177e4
LT		 906 for (len = 0; len < PCF8584_MAX_CHANNELS; ++len) {
907 pchild->mon_type[len] = ENVCTRL_NOMON;
908 }
909 return;
910 }
911 }
912
913 /* Get the monitor channels. */
690c8fd3
DM		 914 pval = of_get_property(dp, "channels-in-use", &len);
915 memcpy(pchild->chnl_array, pval, len);
1da177e4
LT		 916 pchild->total_chnls = len / sizeof(struct pcf8584_channel);
917
918 for (i = 0; i < pchild->total_chnls; i++) {
919 switch (pchild->chnl_array[i].type) {
920 case PCF8584_TEMP_TYPE:
690c8fd3 921 envctrl_init_adc(pchild, dp);
1da177e4
LT		 922 break;
923
924 case PCF8584_GLOBALADDR_TYPE:
925 envctrl_init_globaladdr(pchild);
926 i = pchild->total_chnls;
927 break;
928
929 case PCF8584_FANSTAT_TYPE:
930 envctrl_init_fanstat(pchild);
931 i = pchild->total_chnls;
932 break;
933
934 case PCF8584_VOLTAGE_TYPE:
935 if (pchild->i2ctype == I2C_ADC) {
690c8fd3 936 envctrl_init_adc(pchild,dp);
1da177e4
LT		 937 } else {
938 envctrl_init_voltage_status(pchild);
939 }
940 i = pchild->total_chnls;
941 break;
942
943 default:
944 break;
945 };
946 }
947}
948
949/* Function Description: Search the child device list for a device.
950 * Return : The i2c child if found. NULL otherwise.
951 */
952static struct i2c_child_t *envctrl_get_i2c_child(unsigned char mon_type)
953{
954 int i, j;
955
956 for (i = 0; i < ENVCTRL_MAX_CPU*2; i++) {
957 for (j = 0; j < PCF8584_MAX_CHANNELS; j++) {
958 if (i2c_childlist[i].mon_type[j] == mon_type) {
959 return (struct i2c_child_t *)(&(i2c_childlist[i]));
960 }
961 }
962 }
963 return NULL;
964}
965
966static void envctrl_do_shutdown(void)
967{
968 static int inprog = 0;
969 static char *envp[] = {
970 "HOME=/", "TERM=linux", "PATH=/sbin:/usr/sbin:/bin:/usr/bin", NULL };
971 char *argv[] = {
972 "/sbin/shutdown", "-h", "now", NULL };
3db03b4a 973 int ret;
1da177e4
LT		 974
975 if (inprog != 0)
976 return;
977
978 inprog = 1;
979 printk(KERN_CRIT "kenvctrld: WARNING: Shutting down the system now.\n");
872ec648 980 ret = call_usermodehelper("/sbin/shutdown", argv, envp, 0);
3db03b4a 981 if (ret < 0) {
1da177e4
LT		 982 printk(KERN_CRIT "kenvctrld: WARNING: system shutdown failed!\n");
983 inprog = 0; /* unlikely to succeed, but we could try again */
984 }
985}
986
987static struct task_struct *kenvctrld_task;
988
989static int kenvctrld(void *__unused)
990{
991 int poll_interval;
992 int whichcpu;
993 char tempbuf[10];
994 struct i2c_child_t *cputemp;
995
996 if (NULL == (cputemp = envctrl_get_i2c_child(ENVCTRL_CPUTEMP_MON))) {
997 printk(KERN_ERR
998 "envctrl: kenvctrld unable to monitor CPU temp-- exiting\n");
999 return -ENODEV;
1000 }
1001
cb39d263 1002 poll_interval = 5000; /* TODO env_mon_interval */
1da177e4 1003
1da177e4
LT		 1004 printk(KERN_INFO "envctrl: %s starting...\n", current->comm);
1005 for (;;) {
218b29e0 1006 msleep_interruptible(poll_interval);
1da177e4 1007
218b29e0
CH		 1008 if (kthread_should_stop())
1009 break;
1010
1da177e4
LT		 1011 for (whichcpu = 0; whichcpu < ENVCTRL_MAX_CPU; ++whichcpu) {
1012 if (0 < envctrl_read_cpu_info(whichcpu, cputemp,
1013 ENVCTRL_CPUTEMP_MON,
1014 tempbuf)) {
1015 if (tempbuf[0] >= shutdown_temperature) {
1016 printk(KERN_CRIT
1017 "%s: WARNING: CPU%i temperature %i C meets or exceeds "\
1018 "shutdown threshold %i C\n",
1019 current->comm, whichcpu,
1020 tempbuf[0], shutdown_temperature);
1021 envctrl_do_shutdown();
1022 }
1023 }
1024 }
1025 }
1026 printk(KERN_INFO "envctrl: %s exiting...\n", current->comm);
1027 return 0;
1028}
1029
1030static int __init envctrl_init(void)
1031{
1da177e4
LT		 1032 struct linux_ebus *ebus = NULL;
1033 struct linux_ebus_device *edev = NULL;
1034 struct linux_ebus_child *edev_child = NULL;
1035 int err, i = 0;
1036
1037 for_each_ebus(ebus) {
1038 for_each_ebusdev(edev, ebus) {
690c8fd3 1039 if (!strcmp(edev->prom_node->name, "bbc")) {
1da177e4
LT		 1040 /* If we find a boot-bus controller node,
1041 * then this envctrl driver is not for us.
1042 */
1043 return -ENODEV;
1044 }
1045 }
1046 }
1047
1048 /* Traverse through ebus and ebus device list for i2c device and
1049 * adc and gpio nodes.
1050 */
1051 for_each_ebus(ebus) {
1052 for_each_ebusdev(edev, ebus) {
690c8fd3 1053 if (!strcmp(edev->prom_node->name, "i2c")) {
1da177e4
LT		 1054 i2c = ioremap(edev->resource[0].start, 0x2);
1055 for_each_edevchild(edev, edev_child) {
690c8fd3 1056 if (!strcmp("gpio", edev_child->prom_node->name)) {
1da177e4
LT		 1057 i2c_childlist[i].i2ctype = I2C_GPIO;
1058 envctrl_init_i2c_child(edev_child, &(i2c_childlist[i++]));
1059 }
690c8fd3 1060 if (!strcmp("adc", edev_child->prom_node->name)) {
1da177e4
LT		 1061 i2c_childlist[i].i2ctype = I2C_ADC;
1062 envctrl_init_i2c_child(edev_child, &(i2c_childlist[i++]));
1063 }
1064 }
1065 goto done;
1066 }
1067 }
1068 }
1069
1070done:
1071 if (!edev) {
1072 printk("envctrl: I2C device not found.\n");
1073 return -ENODEV;
1074 }
1075
1076 /* Set device address. */
1077 writeb(CONTROL_PIN, i2c + PCF8584_CSR);
1078 writeb(PCF8584_ADDRESS, i2c + PCF8584_DATA);
1079
1080 /* Set system clock and SCL frequencies. */
1081 writeb(CONTROL_PIN | CONTROL_ES1, i2c + PCF8584_CSR);
1082 writeb(CLK_4_43 | BUS_CLK_90, i2c + PCF8584_DATA);
1083
1084 /* Enable serial interface. */
1085 writeb(CONTROL_PIN | CONTROL_ES0 | CONTROL_ACK, i2c + PCF8584_CSR);
1086 udelay(200);
1087
1088 /* Register the device as a minor miscellaneous device. */
1089 err = misc_register(&envctrl_dev);
1090 if (err) {
1091 printk("envctrl: Unable to get misc minor %d\n",
1092 envctrl_dev.minor);
1093 goto out_iounmap;
1094 }
1095
1096 /* Note above traversal routine post-incremented 'i' to accommodate
1097 * a next child device, so we decrement before reverse-traversal of
1098 * child devices.
1099 */
1100 printk("envctrl: initialized ");
1101 for (--i; i >= 0; --i) {
1102 printk("[%s 0x%lx]%s",
1103 (I2C_ADC == i2c_childlist[i].i2ctype) ? ("adc") :
1104 ((I2C_GPIO == i2c_childlist[i].i2ctype) ? ("gpio") : ("unknown")),
1105 i2c_childlist[i].addr, (0 == i) ? ("\n") : (" "));
1106 }
1107
218b29e0
CH		 1108 kenvctrld_task = kthread_run(kenvctrld, NULL, "kenvctrld");
1109 if (IS_ERR(kenvctrld_task)) {
38c1844b 1110 err = PTR_ERR(kenvctrld_task);
1da177e4 1111 goto out_deregister;
218b29e0 1112 }
1da177e4
LT		 1113
1114 return 0;
1115
1116out_deregister:
1117 misc_deregister(&envctrl_dev);
1118out_iounmap:
1119 iounmap(i2c);
6044ec88
JJ		 1120 for (i = 0; i < ENVCTRL_MAX_CPU * 2; i++)
1121 kfree(i2c_childlist[i].tables);
1122
1da177e4 1123 return err;
1da177e4
LT		 1124}
1125
1126static void __exit envctrl_cleanup(void)
1127{
1128 int i;
1129
218b29e0 1130 kthread_stop(kenvctrld_task);
1da177e4
LT		 1131
1132 iounmap(i2c);
1133 misc_deregister(&envctrl_dev);
1134
6044ec88
JJ		 1135 for (i = 0; i < ENVCTRL_MAX_CPU * 2; i++)
1136 kfree(i2c_childlist[i].tables);
1da177e4
LT		 1137}
1138
1139module_init(envctrl_init);
1140module_exit(envctrl_cleanup);
1141MODULE_LICENSE("GPL");
Linux kernel - Deliverables
This page took 1.297047 seconds and 5 git commands to generate.