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