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