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