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