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