1135 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/* 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) platform7 * 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/PCF8584P12 * http://www-eu2.semiconductors.com/pip/PCF8574AP13 * http://www-eu2.semiconductors.com/pip/PCF8591P14 *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/kthread.h>24#include <linux/delay.h>25#include <linux/ioport.h>26#include <linux/miscdevice.h>27#include <linux/kmod.h>28#include <linux/reboot.h>29#include <linux/slab.h>30#include <linux/of.h>31#include <linux/platform_device.h>32 33#include <linux/uaccess.h>34#include <asm/envctrl.h>35#include <asm/io.h>36 37#define DRIVER_NAME "envctrl"38#define PFX DRIVER_NAME ": "39 40#define PCF8584_ADDRESS 0x5541 42#define CONTROL_PIN 0x8043#define CONTROL_ES0 0x4044#define CONTROL_ES1 0x2045#define CONTROL_ES2 0x1046#define CONTROL_ENI 0x0847#define CONTROL_STA 0x0448#define CONTROL_STO 0x0249#define CONTROL_ACK 0x0150 51#define STATUS_PIN 0x8052#define STATUS_STS 0x2053#define STATUS_BER 0x1054#define STATUS_LRB 0x0855#define STATUS_AD0 0x0856#define STATUS_AAB 0x0457#define STATUS_LAB 0x0258#define STATUS_BB 0x0159 60/*61 * CLK Mode Register.62 */63#define BUS_CLK_90 0x0064#define BUS_CLK_45 0x0165#define BUS_CLK_11 0x0266#define BUS_CLK_1_5 0x0367 68#define CLK_3 0x0069#define CLK_4_43 0x1070#define CLK_6 0x1471#define CLK_8 0x1872#define CLK_12 0x1c73 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 881#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 090#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 temperature */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 temperature */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 decode107 * through a data table and a scale.108 * Translation type as defined by firmware.109 */110#define ENVCTRL_TRANSLATE_NO 0111#define ENVCTRL_TRANSLATE_PARTIAL 1112#define ENVCTRL_TRANSLATE_COMBINED 2113#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 4118#define CHANNEL_DESC_SZ 256119 120/* Mask values for combined GlobalAddress/PowerStatus node */121#define ENVCTRL_GLOBALADDR_ADDR_MASK 0x1F122#define ENVCTRL_GLOBALADDR_PSTAT_MASK 0x60123 124/* Node 0x70 ignored on CompactPCI CP1400/1500 platforms 125 * (see envctrl_init_i2c_child)126 */127#define ENVCTRL_CPCI_IGNORED_NODE 0x70128 129#define PCF8584_DATA 0x00130#define PCF8584_CSR 0x01131 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 */135struct 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 decode143 * data. Table property as defined by the firmware.144 */ 145struct 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 */153struct 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 172static void __iomem *i2c;173static struct i2c_child_t i2c_childlist[ENVCTRL_MAX_CPU*2];174static unsigned char chnls_mask[] = { 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80 };175static unsigned int warning_temperature = 0;176static unsigned int shutdown_temperature = 0;177static char read_cpu;178 179/* Forward declarations. */180static 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 */186static 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 PFX "Pin status will not clear.\n");198}199 200/* Function Description: Test busy bit.201 * Return : None.202 */203static 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 PFX "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 */221static 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 */247static 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 */260static 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 */270static 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 */279static 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 */288static 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 */310static 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 firmware323 * table.324 * Return: Number of read bytes. Data is stored in bufdata in ascii format.325 */326static 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 */362static 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, j = -1;367 char *tbl;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 */397static 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 */427static 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 but445 * return mask are always contiguous. For example if we446 * monitor 4 fans at channels 0,1,2,4, the return mask447 * 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 */466static int envctrl_i2c_globaladdr(struct i2c_child_t *pchild,467 unsigned char data,468 char *bufdata)469{470 /* Translatation table is not necessary, as global471 * 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 degrade480 * 1 = cPCI Power supply output is OK481 * FAL 0 = cPCI Power supply has failed482 * 1 = cPCI Power supply output is OK483 */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 */491static 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 the520 * first channel for voltage and the second for521 * power supply.522 */523 if (j == 1)524 ret = ENVCTRL_VOLTAGE_BAD;525 else526 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 */536static ssize_t537envctrl_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 */653static long654envctrl_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 */696static int697envctrl_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 */706static int707envctrl_release(struct inode *inode, struct file *file)708{709 return 0;710}711 712static const struct file_operations envctrl_fops = {713 .owner = THIS_MODULE,714 .read = envctrl_read,715 .unlocked_ioctl = envctrl_ioctl,716 .compat_ioctl = compat_ptr_ioctl,717 .open = envctrl_open,718 .release = envctrl_release,719 .llseek = noop_llseek,720}; 721 722static struct miscdevice envctrl_dev = {723 ENVCTRL_MINOR,724 "envctrl",725 &envctrl_fops726};727 728/* Function Description: Set monitor type based on firmware description.729 * Return: None.730 */731static void envctrl_set_mon(struct i2c_child_t *pchild,732 const char *chnl_desc,733 int chnl_no)734{735 /* Firmware only has temperature type. It does not distinguish736 * different kinds of temperatures. We use channel description737 * to disinguish them.738 */739 if (!(strcmp(chnl_desc,"temp,cpu")) ||740 !(strcmp(chnl_desc,"temp,cpu0")) ||741 !(strcmp(chnl_desc,"temp,cpu1")) ||742 !(strcmp(chnl_desc,"temp,cpu2")) ||743 !(strcmp(chnl_desc,"temp,cpu3")))744 pchild->mon_type[chnl_no] = ENVCTRL_CPUTEMP_MON;745 746 if (!(strcmp(chnl_desc,"vddcore,cpu0")) ||747 !(strcmp(chnl_desc,"vddcore,cpu1")) ||748 !(strcmp(chnl_desc,"vddcore,cpu2")) ||749 !(strcmp(chnl_desc,"vddcore,cpu3")))750 pchild->mon_type[chnl_no] = ENVCTRL_CPUVOLTAGE_MON;751 752 if (!(strcmp(chnl_desc,"temp,motherboard")))753 pchild->mon_type[chnl_no] = ENVCTRL_MTHRBDTEMP_MON;754 755 if (!(strcmp(chnl_desc,"temp,scsi")))756 pchild->mon_type[chnl_no] = ENVCTRL_SCSITEMP_MON;757 758 if (!(strcmp(chnl_desc,"temp,ethernet")))759 pchild->mon_type[chnl_no] = ENVCTRL_ETHERTEMP_MON;760}761 762/* Function Description: Initialize monitor channel with channel desc,763 * decoding tables, monitor type, optional properties.764 * Return: None.765 */766static void envctrl_init_adc(struct i2c_child_t *pchild, struct device_node *dp)767{768 int i = 0, len;769 const char *pos;770 const unsigned int *pval;771 772 /* Firmware describe channels into a stream separated by a '\0'. */773 pos = of_get_property(dp, "channels-description", &len);774 775 while (len > 0) {776 int l = strlen(pos) + 1;777 envctrl_set_mon(pchild, pos, i++);778 len -= l;779 pos += l;780 }781 782 /* Get optional properties. */783 pval = of_get_property(dp, "warning-temp", NULL);784 if (pval)785 warning_temperature = *pval;786 787 pval = of_get_property(dp, "shutdown-temp", NULL);788 if (pval)789 shutdown_temperature = *pval;790}791 792/* Function Description: Initialize child device monitoring fan status.793 * Return: None.794 */795static void envctrl_init_fanstat(struct i2c_child_t *pchild)796{797 int i;798 799 /* Go through all channels and set up the mask. */800 for (i = 0; i < pchild->total_chnls; i++)801 pchild->fan_mask |= chnls_mask[(pchild->chnl_array[i]).chnl_no];802 803 /* We only need to know if this child has fan status monitored.804 * We don't care which channels since we have the mask already.805 */806 pchild->mon_type[0] = ENVCTRL_FANSTAT_MON;807}808 809/* Function Description: Initialize child device for global addressing line.810 * Return: None.811 */812static void envctrl_init_globaladdr(struct i2c_child_t *pchild)813{814 int i;815 816 /* Voltage/PowerSupply monitoring is piggybacked 817 * with Global Address on CompactPCI. See comments818 * within envctrl_i2c_globaladdr for bit assignments.819 *820 * The mask is created here by assigning mask bits to each821 * bit position that represents PCF8584_VOLTAGE_TYPE data.822 * Channel numbers are not consecutive within the globaladdr823 * node (why?), so we use the actual counter value as chnls_mask824 * index instead of the chnl_array[x].chnl_no value.825 *826 * NOTE: This loop could be replaced with a constant representing827 * a mask of bits 5&6 (ENVCTRL_GLOBALADDR_PSTAT_MASK).828 */829 for (i = 0; i < pchild->total_chnls; i++) {830 if (PCF8584_VOLTAGE_TYPE == pchild->chnl_array[i].type) {831 pchild->voltage_mask |= chnls_mask[i];832 }833 }834 835 /* We only need to know if this child has global addressing 836 * line monitored. We don't care which channels since we know 837 * the mask already (ENVCTRL_GLOBALADDR_ADDR_MASK).838 */839 pchild->mon_type[0] = ENVCTRL_GLOBALADDR_MON;840}841 842/* Initialize child device monitoring voltage status. */843static void envctrl_init_voltage_status(struct i2c_child_t *pchild)844{845 int i;846 847 /* Go through all channels and set up the mask. */848 for (i = 0; i < pchild->total_chnls; i++)849 pchild->voltage_mask |= chnls_mask[(pchild->chnl_array[i]).chnl_no];850 851 /* We only need to know if this child has voltage status monitored.852 * We don't care which channels since we have the mask already.853 */854 pchild->mon_type[0] = ENVCTRL_VOLTAGESTAT_MON;855}856 857/* Function Description: Initialize i2c child device.858 * Return: None.859 */860static void envctrl_init_i2c_child(struct device_node *dp,861 struct i2c_child_t *pchild)862{863 int len, i, tbls_size = 0;864 const void *pval;865 866 /* Get device address. */867 pval = of_get_property(dp, "reg", &len);868 memcpy(&pchild->addr, pval, len);869 870 /* Get tables property. Read firmware temperature tables. */871 pval = of_get_property(dp, "translation", &len);872 if (pval && len > 0) {873 memcpy(pchild->tblprop_array, pval, len);874 pchild->total_tbls = len / sizeof(struct pcf8584_tblprop);875 for (i = 0; i < pchild->total_tbls; i++) {876 if ((pchild->tblprop_array[i].size + pchild->tblprop_array[i].offset) > tbls_size) {877 tbls_size = pchild->tblprop_array[i].size + pchild->tblprop_array[i].offset;878 }879 }880 881 pchild->tables = kmalloc(tbls_size, GFP_KERNEL);882 if (pchild->tables == NULL){883 printk(KERN_ERR PFX "Failed to allocate table.\n");884 return;885 }886 pval = of_get_property(dp, "tables", &len);887 if (!pval || len <= 0) {888 printk(KERN_ERR PFX "Failed to get table.\n");889 return;890 }891 memcpy(pchild->tables, pval, len);892 }893 894 /* SPARCengine ASM Reference Manual (ref. SMI doc 805-7581-04)895 * sections 2.5, 3.5, 4.5 state node 0x70 for CP1400/1500 is896 * "For Factory Use Only."897 *898 * We ignore the node on these platforms by assigning the899 * 'NULL' monitor type.900 */901 if (ENVCTRL_CPCI_IGNORED_NODE == pchild->addr) {902 struct device_node *root_node;903 int len;904 905 root_node = of_find_node_by_path("/");906 if (of_node_name_eq(root_node, "SUNW,UltraSPARC-IIi-cEngine")) {907 for (len = 0; len < PCF8584_MAX_CHANNELS; ++len) {908 pchild->mon_type[len] = ENVCTRL_NOMON;909 }910 of_node_put(root_node);911 return;912 }913 of_node_put(root_node);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 */955static 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 969static void envctrl_do_shutdown(void)970{971 static int inprog = 0;972 973 if (inprog != 0)974 return;975 976 inprog = 1;977 printk(KERN_CRIT "kenvctrld: WARNING: Shutting down the system now.\n");978 orderly_poweroff(true);979}980 981static struct task_struct *kenvctrld_task;982 983static int kenvctrld(void *__unused)984{985 int poll_interval;986 int whichcpu;987 char tempbuf[10];988 struct i2c_child_t *cputemp;989 990 if (NULL == (cputemp = envctrl_get_i2c_child(ENVCTRL_CPUTEMP_MON))) {991 printk(KERN_ERR PFX992 "kenvctrld unable to monitor CPU temp-- exiting\n");993 return -ENODEV;994 }995 996 poll_interval = 5000; /* TODO env_mon_interval */997 998 printk(KERN_INFO PFX "%s starting...\n", current->comm);999 for (;;) {1000 msleep_interruptible(poll_interval);1001 1002 if (kthread_should_stop())1003 break;1004 1005 for (whichcpu = 0; whichcpu < ENVCTRL_MAX_CPU; ++whichcpu) {1006 if (0 < envctrl_read_cpu_info(whichcpu, cputemp,1007 ENVCTRL_CPUTEMP_MON,1008 tempbuf)) {1009 if (tempbuf[0] >= shutdown_temperature) {1010 printk(KERN_CRIT 1011 "%s: WARNING: CPU%i temperature %i C meets or exceeds "\1012 "shutdown threshold %i C\n", 1013 current->comm, whichcpu, 1014 tempbuf[0], shutdown_temperature);1015 envctrl_do_shutdown();1016 }1017 }1018 }1019 }1020 printk(KERN_INFO PFX "%s exiting...\n", current->comm);1021 return 0;1022}1023 1024static int envctrl_probe(struct platform_device *op)1025{1026 struct device_node *dp;1027 int index, err;1028 1029 if (i2c)1030 return -EINVAL;1031 1032 i2c = of_ioremap(&op->resource[0], 0, 0x2, DRIVER_NAME);1033 if (!i2c)1034 return -ENOMEM;1035 1036 index = 0;1037 dp = op->dev.of_node->child;1038 while (dp) {1039 if (of_node_name_eq(dp, "gpio")) {1040 i2c_childlist[index].i2ctype = I2C_GPIO;1041 envctrl_init_i2c_child(dp, &(i2c_childlist[index++]));1042 } else if (of_node_name_eq(dp, "adc")) {1043 i2c_childlist[index].i2ctype = I2C_ADC;1044 envctrl_init_i2c_child(dp, &(i2c_childlist[index++]));1045 }1046 1047 dp = dp->sibling;1048 }1049 1050 /* Set device address. */1051 writeb(CONTROL_PIN, i2c + PCF8584_CSR);1052 writeb(PCF8584_ADDRESS, i2c + PCF8584_DATA);1053 1054 /* Set system clock and SCL frequencies. */ 1055 writeb(CONTROL_PIN | CONTROL_ES1, i2c + PCF8584_CSR);1056 writeb(CLK_4_43 | BUS_CLK_90, i2c + PCF8584_DATA);1057 1058 /* Enable serial interface. */1059 writeb(CONTROL_PIN | CONTROL_ES0 | CONTROL_ACK, i2c + PCF8584_CSR);1060 udelay(200);1061 1062 /* Register the device as a minor miscellaneous device. */1063 err = misc_register(&envctrl_dev);1064 if (err) {1065 printk(KERN_ERR PFX "Unable to get misc minor %d\n",1066 envctrl_dev.minor);1067 goto out_iounmap;1068 }1069 1070 /* Note above traversal routine post-incremented 'i' to accommodate 1071 * a next child device, so we decrement before reverse-traversal of1072 * child devices.1073 */1074 printk(KERN_INFO PFX "Initialized ");1075 for (--index; index >= 0; --index) {1076 printk("[%s 0x%lx]%s", 1077 (I2C_ADC == i2c_childlist[index].i2ctype) ? "adc" : 1078 ((I2C_GPIO == i2c_childlist[index].i2ctype) ? "gpio" : "unknown"), 1079 i2c_childlist[index].addr, (0 == index) ? "\n" : " ");1080 }1081 1082 kenvctrld_task = kthread_run(kenvctrld, NULL, "kenvctrld");1083 if (IS_ERR(kenvctrld_task)) {1084 err = PTR_ERR(kenvctrld_task);1085 goto out_deregister;1086 }1087 1088 return 0;1089 1090out_deregister:1091 misc_deregister(&envctrl_dev);1092out_iounmap:1093 of_iounmap(&op->resource[0], i2c, 0x2);1094 for (index = 0; index < ENVCTRL_MAX_CPU * 2; index++)1095 kfree(i2c_childlist[index].tables);1096 1097 return err;1098}1099 1100static void envctrl_remove(struct platform_device *op)1101{1102 int index;1103 1104 kthread_stop(kenvctrld_task);1105 1106 of_iounmap(&op->resource[0], i2c, 0x2);1107 misc_deregister(&envctrl_dev);1108 1109 for (index = 0; index < ENVCTRL_MAX_CPU * 2; index++)1110 kfree(i2c_childlist[index].tables);1111}1112 1113static const struct of_device_id envctrl_match[] = {1114 {1115 .name = "i2c",1116 .compatible = "i2cpcf,8584",1117 },1118 {},1119};1120MODULE_DEVICE_TABLE(of, envctrl_match);1121 1122static struct platform_driver envctrl_driver = {1123 .driver = {1124 .name = DRIVER_NAME,1125 .of_match_table = envctrl_match,1126 },1127 .probe = envctrl_probe,1128 .remove_new = envctrl_remove,1129};1130 1131module_platform_driver(envctrl_driver);1132 1133MODULE_DESCRIPTION("SUN environment monitoring device driver");1134MODULE_LICENSE("GPL");1135