diff options
author | Linus Torvalds <torvalds@g5.osdl.org> | 2006-07-31 16:39:52 -0400 |
---|---|---|
committer | Linus Torvalds <torvalds@g5.osdl.org> | 2006-07-31 16:39:52 -0400 |
commit | 49b1e3ea19b1c95c2f012b8331ffb3b169e4c042 (patch) | |
tree | 4ccf519a20c9b5bb3701c8b4d38b01af8bef854e /drivers | |
parent | ce38cac48209d270d07fd6d1a8e94446b37abcd5 (diff) | |
parent | 8d950cb8896fc95a9444d190885779438bb9d01c (diff) |
Merge branch 'merge' of git://git.kernel.org/pub/scm/linux/kernel/git/paulus/powerpc
* 'merge' of git://git.kernel.org/pub/scm/linux/kernel/git/paulus/powerpc:
[POWERPC] Minor comment fix for misc_64.S
[POWERPC] Use H_CEDE on non-SMT
[POWERPC] force 64bit mode in fwnmi handlers to workaround firmware bugs
[POWERPC] PMAC_APM_EMU should depend on ADB_PMU
[POWERPC] Fix new interrupt code (MPIC detection)
[POWERPC] Fix new interrupt code (MPIC endianness)
[POWERPC] Add cpufreq support for Xserve G5
[POWERPC] Xserve G5 thermal control fixes
[POWERPC] Fix mem= handling when the memory limit is > RMO size
[POWERPC] More offb/bootx fixes
[POWERPC] Fix legacy_serial.c error handling on 32 bits
[POWERPC] Fix default clock for udbg_16550
[POWERPC] Fix non-MPIC CHRPs with CONFIG_SMP set
[POWERPC] Fix 32 bits warning in prom_init.c
[POWERPC] Workaround Pegasos incorrect ISA "ranges"
[POWERPC] fix up front-LED Kconfig
Diffstat (limited to 'drivers')
-rw-r--r-- | drivers/ide/Kconfig | 14 | ||||
-rw-r--r-- | drivers/macintosh/Kconfig | 11 | ||||
-rw-r--r-- | drivers/macintosh/therm_pm72.c | 218 | ||||
-rw-r--r-- | drivers/macintosh/therm_pm72.h | 33 | ||||
-rw-r--r-- | drivers/macintosh/via-pmu-led.c | 2 | ||||
-rw-r--r-- | drivers/video/offb.c | 307 |
6 files changed, 406 insertions, 179 deletions
diff --git a/drivers/ide/Kconfig b/drivers/ide/Kconfig index 556958ebbf03..b6fb167e20f6 100644 --- a/drivers/ide/Kconfig +++ b/drivers/ide/Kconfig | |||
@@ -774,20 +774,6 @@ config BLK_DEV_IDEDMA_PMAC | |||
774 | to transfer data to and from memory. Saying Y is safe and improves | 774 | to transfer data to and from memory. Saying Y is safe and improves |
775 | performance. | 775 | performance. |
776 | 776 | ||
777 | config BLK_DEV_IDE_PMAC_BLINK | ||
778 | bool "Blink laptop LED on drive activity (DEPRECATED)" | ||
779 | depends on BLK_DEV_IDE_PMAC && ADB_PMU | ||
780 | select ADB_PMU_LED | ||
781 | select LEDS_TRIGGERS | ||
782 | select LEDS_TRIGGER_IDE_DISK | ||
783 | help | ||
784 | This option enables the use of the sleep LED as a hard drive | ||
785 | activity LED. | ||
786 | This option is deprecated, it only selects ADB_PMU_LED and | ||
787 | LEDS_TRIGGER_IDE_DISK and changes the code in the new led class | ||
788 | device to default to the ide-disk trigger (which should be set | ||
789 | from userspace via sysfs). | ||
790 | |||
791 | config BLK_DEV_IDE_SWARM | 777 | config BLK_DEV_IDE_SWARM |
792 | tristate "IDE for Sibyte evaluation boards" | 778 | tristate "IDE for Sibyte evaluation boards" |
793 | depends on SIBYTE_SB1xxx_SOC | 779 | depends on SIBYTE_SB1xxx_SOC |
diff --git a/drivers/macintosh/Kconfig b/drivers/macintosh/Kconfig index d162307e309f..d5d649f5ccdb 100644 --- a/drivers/macintosh/Kconfig +++ b/drivers/macintosh/Kconfig | |||
@@ -90,6 +90,15 @@ config ADB_PMU_LED | |||
90 | and the ide-disk LED trigger and configure appropriately through | 90 | and the ide-disk LED trigger and configure appropriately through |
91 | sysfs. | 91 | sysfs. |
92 | 92 | ||
93 | config ADB_PMU_LED_IDE | ||
94 | bool "Use front LED as IDE LED by default" | ||
95 | depends on ADB_PMU_LED | ||
96 | select LEDS_TRIGGERS | ||
97 | select LEDS_TRIGGER_IDE_DISK | ||
98 | help | ||
99 | This option makes the front LED default to the IDE trigger | ||
100 | so that it blinks on IDE activity. | ||
101 | |||
93 | config PMAC_SMU | 102 | config PMAC_SMU |
94 | bool "Support for SMU based PowerMacs" | 103 | bool "Support for SMU based PowerMacs" |
95 | depends on PPC_PMAC64 | 104 | depends on PPC_PMAC64 |
@@ -100,7 +109,7 @@ config PMAC_SMU | |||
100 | 109 | ||
101 | config PMAC_APM_EMU | 110 | config PMAC_APM_EMU |
102 | tristate "APM emulation" | 111 | tristate "APM emulation" |
103 | depends on PPC_PMAC && PPC32 && PM | 112 | depends on PPC_PMAC && PPC32 && PM && ADB_PMU |
104 | 113 | ||
105 | config PMAC_MEDIABAY | 114 | config PMAC_MEDIABAY |
106 | bool "Support PowerBook hotswap media bay" | 115 | bool "Support PowerBook hotswap media bay" |
diff --git a/drivers/macintosh/therm_pm72.c b/drivers/macintosh/therm_pm72.c index c1fe0b368f76..20bf67244e2c 100644 --- a/drivers/macintosh/therm_pm72.c +++ b/drivers/macintosh/therm_pm72.c | |||
@@ -95,6 +95,17 @@ | |||
95 | * - Use min/max macros here or there | 95 | * - Use min/max macros here or there |
96 | * - Latest darwin updated U3H min fan speed to 20% PWM | 96 | * - Latest darwin updated U3H min fan speed to 20% PWM |
97 | * | 97 | * |
98 | * July. 06, 2006 : 1.3 | ||
99 | * - Fix setting of RPM fans on Xserve G5 (they were going too fast) | ||
100 | * - Add missing slots fan control loop for Xserve G5 | ||
101 | * - Lower fixed slots fan speed from 50% to 40% on desktop G5s. We | ||
102 | * still can't properly implement the control loop for these, so let's | ||
103 | * reduce the noise a little bit, it appears that 40% still gives us | ||
104 | * a pretty good air flow | ||
105 | * - Add code to "tickle" the FCU regulary so it doesn't think that | ||
106 | * we are gone while in fact, the machine just didn't need any fan | ||
107 | * speed change lately | ||
108 | * | ||
98 | */ | 109 | */ |
99 | 110 | ||
100 | #include <linux/types.h> | 111 | #include <linux/types.h> |
@@ -121,7 +132,7 @@ | |||
121 | 132 | ||
122 | #include "therm_pm72.h" | 133 | #include "therm_pm72.h" |
123 | 134 | ||
124 | #define VERSION "1.2b2" | 135 | #define VERSION "1.3" |
125 | 136 | ||
126 | #undef DEBUG | 137 | #undef DEBUG |
127 | 138 | ||
@@ -146,6 +157,7 @@ static struct basckside_pid_params backside_params; | |||
146 | static struct backside_pid_state backside_state; | 157 | static struct backside_pid_state backside_state; |
147 | static struct drives_pid_state drives_state; | 158 | static struct drives_pid_state drives_state; |
148 | static struct dimm_pid_state dimms_state; | 159 | static struct dimm_pid_state dimms_state; |
160 | static struct slots_pid_state slots_state; | ||
149 | static int state; | 161 | static int state; |
150 | static int cpu_count; | 162 | static int cpu_count; |
151 | static int cpu_pid_type; | 163 | static int cpu_pid_type; |
@@ -154,7 +166,8 @@ static struct completion ctrl_complete; | |||
154 | static int critical_state; | 166 | static int critical_state; |
155 | static int rackmac; | 167 | static int rackmac; |
156 | static s32 dimm_output_clamp; | 168 | static s32 dimm_output_clamp; |
157 | 169 | static int fcu_rpm_shift; | |
170 | static int fcu_tickle_ticks; | ||
158 | static DECLARE_MUTEX(driver_lock); | 171 | static DECLARE_MUTEX(driver_lock); |
159 | 172 | ||
160 | /* | 173 | /* |
@@ -495,13 +508,20 @@ static int start_fcu(void) | |||
495 | rc = fan_write_reg(0x2e, &buf, 1); | 508 | rc = fan_write_reg(0x2e, &buf, 1); |
496 | if (rc < 0) | 509 | if (rc < 0) |
497 | return -EIO; | 510 | return -EIO; |
511 | rc = fan_read_reg(0, &buf, 1); | ||
512 | if (rc < 0) | ||
513 | return -EIO; | ||
514 | fcu_rpm_shift = (buf == 1) ? 2 : 3; | ||
515 | printk(KERN_DEBUG "FCU Initialized, RPM fan shift is %d\n", | ||
516 | fcu_rpm_shift); | ||
517 | |||
498 | return 0; | 518 | return 0; |
499 | } | 519 | } |
500 | 520 | ||
501 | static int set_rpm_fan(int fan_index, int rpm) | 521 | static int set_rpm_fan(int fan_index, int rpm) |
502 | { | 522 | { |
503 | unsigned char buf[2]; | 523 | unsigned char buf[2]; |
504 | int rc, id; | 524 | int rc, id, min, max; |
505 | 525 | ||
506 | if (fcu_fans[fan_index].type != FCU_FAN_RPM) | 526 | if (fcu_fans[fan_index].type != FCU_FAN_RPM) |
507 | return -EINVAL; | 527 | return -EINVAL; |
@@ -509,12 +529,15 @@ static int set_rpm_fan(int fan_index, int rpm) | |||
509 | if (id == FCU_FAN_ABSENT_ID) | 529 | if (id == FCU_FAN_ABSENT_ID) |
510 | return -EINVAL; | 530 | return -EINVAL; |
511 | 531 | ||
512 | if (rpm < 300) | 532 | min = 2400 >> fcu_rpm_shift; |
513 | rpm = 300; | 533 | max = 56000 >> fcu_rpm_shift; |
514 | else if (rpm > 8191) | 534 | |
515 | rpm = 8191; | 535 | if (rpm < min) |
516 | buf[0] = rpm >> 5; | 536 | rpm = min; |
517 | buf[1] = rpm << 3; | 537 | else if (rpm > max) |
538 | rpm = max; | ||
539 | buf[0] = rpm >> (8 - fcu_rpm_shift); | ||
540 | buf[1] = rpm << fcu_rpm_shift; | ||
518 | rc = fan_write_reg(0x10 + (id * 2), buf, 2); | 541 | rc = fan_write_reg(0x10 + (id * 2), buf, 2); |
519 | if (rc < 0) | 542 | if (rc < 0) |
520 | return -EIO; | 543 | return -EIO; |
@@ -551,7 +574,7 @@ static int get_rpm_fan(int fan_index, int programmed) | |||
551 | if (rc != 2) | 574 | if (rc != 2) |
552 | return -EIO; | 575 | return -EIO; |
553 | 576 | ||
554 | return (buf[0] << 5) | buf[1] >> 3; | 577 | return (buf[0] << (8 - fcu_rpm_shift)) | buf[1] >> fcu_rpm_shift; |
555 | } | 578 | } |
556 | 579 | ||
557 | static int set_pwm_fan(int fan_index, int pwm) | 580 | static int set_pwm_fan(int fan_index, int pwm) |
@@ -609,6 +632,26 @@ static int get_pwm_fan(int fan_index) | |||
609 | return (buf[0] * 1000) / 2559; | 632 | return (buf[0] * 1000) / 2559; |
610 | } | 633 | } |
611 | 634 | ||
635 | static void tickle_fcu(void) | ||
636 | { | ||
637 | int pwm; | ||
638 | |||
639 | pwm = get_pwm_fan(SLOTS_FAN_PWM_INDEX); | ||
640 | |||
641 | DBG("FCU Tickle, slots fan is: %d\n", pwm); | ||
642 | if (pwm < 0) | ||
643 | pwm = 100; | ||
644 | |||
645 | if (!rackmac) { | ||
646 | pwm = SLOTS_FAN_DEFAULT_PWM; | ||
647 | } else if (pwm < SLOTS_PID_OUTPUT_MIN) | ||
648 | pwm = SLOTS_PID_OUTPUT_MIN; | ||
649 | |||
650 | /* That is hopefully enough to make the FCU happy */ | ||
651 | set_pwm_fan(SLOTS_FAN_PWM_INDEX, pwm); | ||
652 | } | ||
653 | |||
654 | |||
612 | /* | 655 | /* |
613 | * Utility routine to read the CPU calibration EEPROM data | 656 | * Utility routine to read the CPU calibration EEPROM data |
614 | * from the device-tree | 657 | * from the device-tree |
@@ -715,6 +758,9 @@ BUILD_SHOW_FUNC_INT(backside_fan_pwm, backside_state.pwm) | |||
715 | BUILD_SHOW_FUNC_FIX(drives_temperature, drives_state.last_temp) | 758 | BUILD_SHOW_FUNC_FIX(drives_temperature, drives_state.last_temp) |
716 | BUILD_SHOW_FUNC_INT(drives_fan_rpm, drives_state.rpm) | 759 | BUILD_SHOW_FUNC_INT(drives_fan_rpm, drives_state.rpm) |
717 | 760 | ||
761 | BUILD_SHOW_FUNC_FIX(slots_temperature, slots_state.last_temp) | ||
762 | BUILD_SHOW_FUNC_INT(slots_fan_pwm, slots_state.pwm) | ||
763 | |||
718 | BUILD_SHOW_FUNC_FIX(dimms_temperature, dimms_state.last_temp) | 764 | BUILD_SHOW_FUNC_FIX(dimms_temperature, dimms_state.last_temp) |
719 | 765 | ||
720 | static DEVICE_ATTR(cpu0_temperature,S_IRUGO,show_cpu0_temperature,NULL); | 766 | static DEVICE_ATTR(cpu0_temperature,S_IRUGO,show_cpu0_temperature,NULL); |
@@ -735,6 +781,9 @@ static DEVICE_ATTR(backside_fan_pwm,S_IRUGO,show_backside_fan_pwm,NULL); | |||
735 | static DEVICE_ATTR(drives_temperature,S_IRUGO,show_drives_temperature,NULL); | 781 | static DEVICE_ATTR(drives_temperature,S_IRUGO,show_drives_temperature,NULL); |
736 | static DEVICE_ATTR(drives_fan_rpm,S_IRUGO,show_drives_fan_rpm,NULL); | 782 | static DEVICE_ATTR(drives_fan_rpm,S_IRUGO,show_drives_fan_rpm,NULL); |
737 | 783 | ||
784 | static DEVICE_ATTR(slots_temperature,S_IRUGO,show_slots_temperature,NULL); | ||
785 | static DEVICE_ATTR(slots_fan_pwm,S_IRUGO,show_slots_fan_pwm,NULL); | ||
786 | |||
738 | static DEVICE_ATTR(dimms_temperature,S_IRUGO,show_dimms_temperature,NULL); | 787 | static DEVICE_ATTR(dimms_temperature,S_IRUGO,show_dimms_temperature,NULL); |
739 | 788 | ||
740 | /* | 789 | /* |
@@ -1076,6 +1125,9 @@ static void do_monitor_cpu_rack(struct cpu_pid_state *state) | |||
1076 | fan_min = dimm_output_clamp; | 1125 | fan_min = dimm_output_clamp; |
1077 | fan_min = max(fan_min, (int)state->mpu.rminn_intake_fan); | 1126 | fan_min = max(fan_min, (int)state->mpu.rminn_intake_fan); |
1078 | 1127 | ||
1128 | DBG(" CPU min mpu = %d, min dimm = %d\n", | ||
1129 | state->mpu.rminn_intake_fan, dimm_output_clamp); | ||
1130 | |||
1079 | state->rpm = max(state->rpm, (int)fan_min); | 1131 | state->rpm = max(state->rpm, (int)fan_min); |
1080 | state->rpm = min(state->rpm, (int)state->mpu.rmaxn_intake_fan); | 1132 | state->rpm = min(state->rpm, (int)state->mpu.rmaxn_intake_fan); |
1081 | state->intake_rpm = state->rpm; | 1133 | state->intake_rpm = state->rpm; |
@@ -1374,7 +1426,8 @@ static void do_monitor_drives(struct drives_pid_state *state) | |||
1374 | DBG(" current rpm: %d\n", state->rpm); | 1426 | DBG(" current rpm: %d\n", state->rpm); |
1375 | 1427 | ||
1376 | /* Get some sensor readings */ | 1428 | /* Get some sensor readings */ |
1377 | temp = le16_to_cpu(i2c_smbus_read_word_data(state->monitor, DS1775_TEMP)) << 8; | 1429 | temp = le16_to_cpu(i2c_smbus_read_word_data(state->monitor, |
1430 | DS1775_TEMP)) << 8; | ||
1378 | state->last_temp = temp; | 1431 | state->last_temp = temp; |
1379 | DBG(" temp: %d.%03d, target: %d.%03d\n", FIX32TOPRINT(temp), | 1432 | DBG(" temp: %d.%03d, target: %d.%03d\n", FIX32TOPRINT(temp), |
1380 | FIX32TOPRINT(DRIVES_PID_INPUT_TARGET)); | 1433 | FIX32TOPRINT(DRIVES_PID_INPUT_TARGET)); |
@@ -1575,7 +1628,7 @@ static int init_dimms_state(struct dimm_pid_state *state) | |||
1575 | } | 1628 | } |
1576 | 1629 | ||
1577 | /* | 1630 | /* |
1578 | * Dispose of the state data for the drives control loop | 1631 | * Dispose of the state data for the DIMM control loop |
1579 | */ | 1632 | */ |
1580 | static void dispose_dimms_state(struct dimm_pid_state *state) | 1633 | static void dispose_dimms_state(struct dimm_pid_state *state) |
1581 | { | 1634 | { |
@@ -1588,6 +1641,127 @@ static void dispose_dimms_state(struct dimm_pid_state *state) | |||
1588 | state->monitor = NULL; | 1641 | state->monitor = NULL; |
1589 | } | 1642 | } |
1590 | 1643 | ||
1644 | /* | ||
1645 | * Slots fan control loop | ||
1646 | */ | ||
1647 | static void do_monitor_slots(struct slots_pid_state *state) | ||
1648 | { | ||
1649 | s32 temp, integral, derivative; | ||
1650 | s64 integ_p, deriv_p, prop_p, sum; | ||
1651 | int i, rc; | ||
1652 | |||
1653 | if (--state->ticks != 0) | ||
1654 | return; | ||
1655 | state->ticks = SLOTS_PID_INTERVAL; | ||
1656 | |||
1657 | DBG("slots:\n"); | ||
1658 | |||
1659 | /* Check fan status */ | ||
1660 | rc = get_pwm_fan(SLOTS_FAN_PWM_INDEX); | ||
1661 | if (rc < 0) { | ||
1662 | printk(KERN_WARNING "Error %d reading slots fan !\n", rc); | ||
1663 | /* XXX What do we do now ? */ | ||
1664 | } else | ||
1665 | state->pwm = rc; | ||
1666 | DBG(" current pwm: %d\n", state->pwm); | ||
1667 | |||
1668 | /* Get some sensor readings */ | ||
1669 | temp = le16_to_cpu(i2c_smbus_read_word_data(state->monitor, | ||
1670 | DS1775_TEMP)) << 8; | ||
1671 | state->last_temp = temp; | ||
1672 | DBG(" temp: %d.%03d, target: %d.%03d\n", FIX32TOPRINT(temp), | ||
1673 | FIX32TOPRINT(SLOTS_PID_INPUT_TARGET)); | ||
1674 | |||
1675 | /* Store temperature and error in history array */ | ||
1676 | state->cur_sample = (state->cur_sample + 1) % SLOTS_PID_HISTORY_SIZE; | ||
1677 | state->sample_history[state->cur_sample] = temp; | ||
1678 | state->error_history[state->cur_sample] = temp - SLOTS_PID_INPUT_TARGET; | ||
1679 | |||
1680 | /* If first loop, fill the history table */ | ||
1681 | if (state->first) { | ||
1682 | for (i = 0; i < (SLOTS_PID_HISTORY_SIZE - 1); i++) { | ||
1683 | state->cur_sample = (state->cur_sample + 1) % | ||
1684 | SLOTS_PID_HISTORY_SIZE; | ||
1685 | state->sample_history[state->cur_sample] = temp; | ||
1686 | state->error_history[state->cur_sample] = | ||
1687 | temp - SLOTS_PID_INPUT_TARGET; | ||
1688 | } | ||
1689 | state->first = 0; | ||
1690 | } | ||
1691 | |||
1692 | /* Calculate the integral term */ | ||
1693 | sum = 0; | ||
1694 | integral = 0; | ||
1695 | for (i = 0; i < SLOTS_PID_HISTORY_SIZE; i++) | ||
1696 | integral += state->error_history[i]; | ||
1697 | integral *= SLOTS_PID_INTERVAL; | ||
1698 | DBG(" integral: %08x\n", integral); | ||
1699 | integ_p = ((s64)SLOTS_PID_G_r) * (s64)integral; | ||
1700 | DBG(" integ_p: %d\n", (int)(integ_p >> 36)); | ||
1701 | sum += integ_p; | ||
1702 | |||
1703 | /* Calculate the derivative term */ | ||
1704 | derivative = state->error_history[state->cur_sample] - | ||
1705 | state->error_history[(state->cur_sample + SLOTS_PID_HISTORY_SIZE - 1) | ||
1706 | % SLOTS_PID_HISTORY_SIZE]; | ||
1707 | derivative /= SLOTS_PID_INTERVAL; | ||
1708 | deriv_p = ((s64)SLOTS_PID_G_d) * (s64)derivative; | ||
1709 | DBG(" deriv_p: %d\n", (int)(deriv_p >> 36)); | ||
1710 | sum += deriv_p; | ||
1711 | |||
1712 | /* Calculate the proportional term */ | ||
1713 | prop_p = ((s64)SLOTS_PID_G_p) * (s64)(state->error_history[state->cur_sample]); | ||
1714 | DBG(" prop_p: %d\n", (int)(prop_p >> 36)); | ||
1715 | sum += prop_p; | ||
1716 | |||
1717 | /* Scale sum */ | ||
1718 | sum >>= 36; | ||
1719 | |||
1720 | DBG(" sum: %d\n", (int)sum); | ||
1721 | state->pwm = (s32)sum; | ||
1722 | |||
1723 | state->pwm = max(state->pwm, SLOTS_PID_OUTPUT_MIN); | ||
1724 | state->pwm = min(state->pwm, SLOTS_PID_OUTPUT_MAX); | ||
1725 | |||
1726 | DBG("** DRIVES PWM: %d\n", (int)state->pwm); | ||
1727 | set_pwm_fan(SLOTS_FAN_PWM_INDEX, state->pwm); | ||
1728 | } | ||
1729 | |||
1730 | /* | ||
1731 | * Initialize the state structure for the slots bay fan control loop | ||
1732 | */ | ||
1733 | static int init_slots_state(struct slots_pid_state *state) | ||
1734 | { | ||
1735 | state->ticks = 1; | ||
1736 | state->first = 1; | ||
1737 | state->pwm = 50; | ||
1738 | |||
1739 | state->monitor = attach_i2c_chip(XSERVE_SLOTS_LM75, "slots_temp"); | ||
1740 | if (state->monitor == NULL) | ||
1741 | return -ENODEV; | ||
1742 | |||
1743 | device_create_file(&of_dev->dev, &dev_attr_slots_temperature); | ||
1744 | device_create_file(&of_dev->dev, &dev_attr_slots_fan_pwm); | ||
1745 | |||
1746 | return 0; | ||
1747 | } | ||
1748 | |||
1749 | /* | ||
1750 | * Dispose of the state data for the slots control loop | ||
1751 | */ | ||
1752 | static void dispose_slots_state(struct slots_pid_state *state) | ||
1753 | { | ||
1754 | if (state->monitor == NULL) | ||
1755 | return; | ||
1756 | |||
1757 | device_remove_file(&of_dev->dev, &dev_attr_slots_temperature); | ||
1758 | device_remove_file(&of_dev->dev, &dev_attr_slots_fan_pwm); | ||
1759 | |||
1760 | detach_i2c_chip(state->monitor); | ||
1761 | state->monitor = NULL; | ||
1762 | } | ||
1763 | |||
1764 | |||
1591 | static int call_critical_overtemp(void) | 1765 | static int call_critical_overtemp(void) |
1592 | { | 1766 | { |
1593 | char *argv[] = { critical_overtemp_path, NULL }; | 1767 | char *argv[] = { critical_overtemp_path, NULL }; |
@@ -1617,14 +1791,17 @@ static int main_control_loop(void *x) | |||
1617 | goto out; | 1791 | goto out; |
1618 | } | 1792 | } |
1619 | 1793 | ||
1620 | /* Set the PCI fan once for now */ | 1794 | /* Set the PCI fan once for now on non-RackMac */ |
1621 | set_pwm_fan(SLOTS_FAN_PWM_INDEX, SLOTS_FAN_DEFAULT_PWM); | 1795 | if (!rackmac) |
1796 | set_pwm_fan(SLOTS_FAN_PWM_INDEX, SLOTS_FAN_DEFAULT_PWM); | ||
1622 | 1797 | ||
1623 | /* Initialize ADCs */ | 1798 | /* Initialize ADCs */ |
1624 | initialize_adc(&cpu_state[0]); | 1799 | initialize_adc(&cpu_state[0]); |
1625 | if (cpu_state[1].monitor != NULL) | 1800 | if (cpu_state[1].monitor != NULL) |
1626 | initialize_adc(&cpu_state[1]); | 1801 | initialize_adc(&cpu_state[1]); |
1627 | 1802 | ||
1803 | fcu_tickle_ticks = FCU_TICKLE_TICKS; | ||
1804 | |||
1628 | up(&driver_lock); | 1805 | up(&driver_lock); |
1629 | 1806 | ||
1630 | while (state == state_attached) { | 1807 | while (state == state_attached) { |
@@ -1634,6 +1811,12 @@ static int main_control_loop(void *x) | |||
1634 | 1811 | ||
1635 | down(&driver_lock); | 1812 | down(&driver_lock); |
1636 | 1813 | ||
1814 | /* Tickle the FCU just in case */ | ||
1815 | if (--fcu_tickle_ticks < 0) { | ||
1816 | fcu_tickle_ticks = FCU_TICKLE_TICKS; | ||
1817 | tickle_fcu(); | ||
1818 | } | ||
1819 | |||
1637 | /* First, we always calculate the new DIMMs state on an Xserve */ | 1820 | /* First, we always calculate the new DIMMs state on an Xserve */ |
1638 | if (rackmac) | 1821 | if (rackmac) |
1639 | do_monitor_dimms(&dimms_state); | 1822 | do_monitor_dimms(&dimms_state); |
@@ -1654,7 +1837,9 @@ static int main_control_loop(void *x) | |||
1654 | } | 1837 | } |
1655 | /* Then, the rest */ | 1838 | /* Then, the rest */ |
1656 | do_monitor_backside(&backside_state); | 1839 | do_monitor_backside(&backside_state); |
1657 | if (!rackmac) | 1840 | if (rackmac) |
1841 | do_monitor_slots(&slots_state); | ||
1842 | else | ||
1658 | do_monitor_drives(&drives_state); | 1843 | do_monitor_drives(&drives_state); |
1659 | up(&driver_lock); | 1844 | up(&driver_lock); |
1660 | 1845 | ||
@@ -1696,6 +1881,7 @@ static void dispose_control_loops(void) | |||
1696 | dispose_cpu_state(&cpu_state[1]); | 1881 | dispose_cpu_state(&cpu_state[1]); |
1697 | dispose_backside_state(&backside_state); | 1882 | dispose_backside_state(&backside_state); |
1698 | dispose_drives_state(&drives_state); | 1883 | dispose_drives_state(&drives_state); |
1884 | dispose_slots_state(&slots_state); | ||
1699 | dispose_dimms_state(&dimms_state); | 1885 | dispose_dimms_state(&dimms_state); |
1700 | } | 1886 | } |
1701 | 1887 | ||
@@ -1745,6 +1931,8 @@ static int create_control_loops(void) | |||
1745 | goto fail; | 1931 | goto fail; |
1746 | if (rackmac && init_dimms_state(&dimms_state)) | 1932 | if (rackmac && init_dimms_state(&dimms_state)) |
1747 | goto fail; | 1933 | goto fail; |
1934 | if (rackmac && init_slots_state(&slots_state)) | ||
1935 | goto fail; | ||
1748 | if (!rackmac && init_drives_state(&drives_state)) | 1936 | if (!rackmac && init_drives_state(&drives_state)) |
1749 | goto fail; | 1937 | goto fail; |
1750 | 1938 | ||
diff --git a/drivers/macintosh/therm_pm72.h b/drivers/macintosh/therm_pm72.h index fc7e9b7ecaf2..393cc9df94e1 100644 --- a/drivers/macintosh/therm_pm72.h +++ b/drivers/macintosh/therm_pm72.h | |||
@@ -105,6 +105,7 @@ static char * critical_overtemp_path = "/sbin/critical_overtemp"; | |||
105 | #define DRIVES_DALLAS_ID 0x94 | 105 | #define DRIVES_DALLAS_ID 0x94 |
106 | #define BACKSIDE_MAX_ID 0x98 | 106 | #define BACKSIDE_MAX_ID 0x98 |
107 | #define XSERVE_DIMMS_LM87 0x25a | 107 | #define XSERVE_DIMMS_LM87 0x25a |
108 | #define XSERVE_SLOTS_LM75 0x290 | ||
108 | 109 | ||
109 | /* | 110 | /* |
110 | * Some MAX6690, DS1775, LM87 register definitions | 111 | * Some MAX6690, DS1775, LM87 register definitions |
@@ -198,7 +199,7 @@ struct drives_pid_state | |||
198 | 199 | ||
199 | #define SLOTS_FAN_PWM_DEFAULT_ID 2 | 200 | #define SLOTS_FAN_PWM_DEFAULT_ID 2 |
200 | #define SLOTS_FAN_PWM_INDEX 2 | 201 | #define SLOTS_FAN_PWM_INDEX 2 |
201 | #define SLOTS_FAN_DEFAULT_PWM 50 /* Do better here ! */ | 202 | #define SLOTS_FAN_DEFAULT_PWM 40 /* Do better here ! */ |
202 | 203 | ||
203 | 204 | ||
204 | /* | 205 | /* |
@@ -206,7 +207,7 @@ struct drives_pid_state | |||
206 | */ | 207 | */ |
207 | #define DIMM_PID_G_d 0 | 208 | #define DIMM_PID_G_d 0 |
208 | #define DIMM_PID_G_p 0 | 209 | #define DIMM_PID_G_p 0 |
209 | #define DIMM_PID_G_r 0x6553600 | 210 | #define DIMM_PID_G_r 0x06553600 |
210 | #define DIMM_PID_INPUT_TARGET 3276800 | 211 | #define DIMM_PID_INPUT_TARGET 3276800 |
211 | #define DIMM_PID_INTERVAL 1 | 212 | #define DIMM_PID_INTERVAL 1 |
212 | #define DIMM_PID_OUTPUT_MAX 14000 | 213 | #define DIMM_PID_OUTPUT_MAX 14000 |
@@ -226,6 +227,31 @@ struct dimm_pid_state | |||
226 | }; | 227 | }; |
227 | 228 | ||
228 | 229 | ||
230 | /* | ||
231 | * PID factors for the Xserve Slots control loop | ||
232 | */ | ||
233 | #define SLOTS_PID_G_d 0 | ||
234 | #define SLOTS_PID_G_p 0 | ||
235 | #define SLOTS_PID_G_r 0x00100000 | ||
236 | #define SLOTS_PID_INPUT_TARGET 3200000 | ||
237 | #define SLOTS_PID_INTERVAL 1 | ||
238 | #define SLOTS_PID_OUTPUT_MAX 100 | ||
239 | #define SLOTS_PID_OUTPUT_MIN 20 | ||
240 | #define SLOTS_PID_HISTORY_SIZE 20 | ||
241 | |||
242 | struct slots_pid_state | ||
243 | { | ||
244 | int ticks; | ||
245 | struct i2c_client * monitor; | ||
246 | s32 sample_history[SLOTS_PID_HISTORY_SIZE]; | ||
247 | s32 error_history[SLOTS_PID_HISTORY_SIZE]; | ||
248 | int cur_sample; | ||
249 | s32 last_temp; | ||
250 | int first; | ||
251 | int pwm; | ||
252 | }; | ||
253 | |||
254 | |||
229 | 255 | ||
230 | /* Desktops */ | 256 | /* Desktops */ |
231 | 257 | ||
@@ -283,6 +309,9 @@ struct cpu_pid_state | |||
283 | s32 pump_max; | 309 | s32 pump_max; |
284 | }; | 310 | }; |
285 | 311 | ||
312 | /* Tickle FCU every 10 seconds */ | ||
313 | #define FCU_TICKLE_TICKS 10 | ||
314 | |||
286 | /* | 315 | /* |
287 | * Driver state | 316 | * Driver state |
288 | */ | 317 | */ |
diff --git a/drivers/macintosh/via-pmu-led.c b/drivers/macintosh/via-pmu-led.c index af8375ed0f5e..5189d5454b1f 100644 --- a/drivers/macintosh/via-pmu-led.c +++ b/drivers/macintosh/via-pmu-led.c | |||
@@ -74,7 +74,7 @@ static void pmu_led_set(struct led_classdev *led_cdev, | |||
74 | 74 | ||
75 | static struct led_classdev pmu_led = { | 75 | static struct led_classdev pmu_led = { |
76 | .name = "pmu-front-led", | 76 | .name = "pmu-front-led", |
77 | #ifdef CONFIG_BLK_DEV_IDE_PMAC_BLINK | 77 | #ifdef CONFIG_ADB_PMU_LED_IDE |
78 | .default_trigger = "ide-disk", | 78 | .default_trigger = "ide-disk", |
79 | #endif | 79 | #endif |
80 | .brightness_set = pmu_led_set, | 80 | .brightness_set = pmu_led_set, |
diff --git a/drivers/video/offb.c b/drivers/video/offb.c index ce5f3031b99b..0013311e0564 100644 --- a/drivers/video/offb.c +++ b/drivers/video/offb.c | |||
@@ -62,8 +62,6 @@ struct offb_par default_par; | |||
62 | * Interface used by the world | 62 | * Interface used by the world |
63 | */ | 63 | */ |
64 | 64 | ||
65 | int offb_init(void); | ||
66 | |||
67 | static int offb_setcolreg(u_int regno, u_int red, u_int green, u_int blue, | 65 | static int offb_setcolreg(u_int regno, u_int red, u_int green, u_int blue, |
68 | u_int transp, struct fb_info *info); | 66 | u_int transp, struct fb_info *info); |
69 | static int offb_blank(int blank, struct fb_info *info); | 67 | static int offb_blank(int blank, struct fb_info *info); |
@@ -72,11 +70,6 @@ static int offb_blank(int blank, struct fb_info *info); | |||
72 | extern boot_infos_t *boot_infos; | 70 | extern boot_infos_t *boot_infos; |
73 | #endif | 71 | #endif |
74 | 72 | ||
75 | static void offb_init_nodriver(struct device_node *); | ||
76 | static void offb_init_fb(const char *name, const char *full_name, | ||
77 | int width, int height, int depth, int pitch, | ||
78 | unsigned long address, struct device_node *dp); | ||
79 | |||
80 | static struct fb_ops offb_ops = { | 73 | static struct fb_ops offb_ops = { |
81 | .owner = THIS_MODULE, | 74 | .owner = THIS_MODULE, |
82 | .fb_setcolreg = offb_setcolreg, | 75 | .fb_setcolreg = offb_setcolreg, |
@@ -229,123 +222,17 @@ static int offb_blank(int blank, struct fb_info *info) | |||
229 | return 0; | 222 | return 0; |
230 | } | 223 | } |
231 | 224 | ||
232 | /* | ||
233 | * Initialisation | ||
234 | */ | ||
235 | 225 | ||
236 | int __init offb_init(void) | 226 | static void __iomem *offb_map_reg(struct device_node *np, int index, |
227 | unsigned long offset, unsigned long size) | ||
237 | { | 228 | { |
238 | struct device_node *dp = NULL, *boot_disp = NULL; | 229 | struct resource r; |
239 | |||
240 | if (fb_get_options("offb", NULL)) | ||
241 | return -ENODEV; | ||
242 | 230 | ||
243 | for (dp = NULL; (dp = of_find_node_by_type(dp, "display"));) { | 231 | if (of_address_to_resource(np, index, &r)) |
244 | if (get_property(dp, "linux,opened", NULL) && | 232 | return 0; |
245 | get_property(dp, "linux,boot-display", NULL)) { | 233 | if ((r.start + offset + size) > r.end) |
246 | boot_disp = dp; | 234 | return 0; |
247 | offb_init_nodriver(dp); | 235 | return ioremap(r.start + offset, size); |
248 | } | ||
249 | } | ||
250 | for (dp = NULL; (dp = of_find_node_by_type(dp, "display"));) { | ||
251 | if (get_property(dp, "linux,opened", NULL) && | ||
252 | dp != boot_disp) | ||
253 | offb_init_nodriver(dp); | ||
254 | } | ||
255 | |||
256 | return 0; | ||
257 | } | ||
258 | |||
259 | |||
260 | static void __init offb_init_nodriver(struct device_node *dp) | ||
261 | { | ||
262 | unsigned int len; | ||
263 | int i, width = 640, height = 480, depth = 8, pitch = 640; | ||
264 | unsigned int flags, rsize, addr_prop = 0; | ||
265 | unsigned long max_size = 0; | ||
266 | u64 rstart, address = OF_BAD_ADDR; | ||
267 | u32 *pp, *addrp, *up; | ||
268 | u64 asize; | ||
269 | |||
270 | pp = (u32 *)get_property(dp, "linux,bootx-depth", &len); | ||
271 | if (pp == NULL) | ||
272 | pp = (u32 *)get_property(dp, "depth", &len); | ||
273 | if (pp && len == sizeof(u32)) | ||
274 | depth = *pp; | ||
275 | |||
276 | pp = (u32 *)get_property(dp, "linux,bootx-width", &len); | ||
277 | if (pp == NULL) | ||
278 | pp = (u32 *)get_property(dp, "width", &len); | ||
279 | if (pp && len == sizeof(u32)) | ||
280 | width = *pp; | ||
281 | |||
282 | pp = (u32 *)get_property(dp, "linux,bootx-height", &len); | ||
283 | if (pp == NULL) | ||
284 | pp = (u32 *)get_property(dp, "height", &len); | ||
285 | if (pp && len == sizeof(u32)) | ||
286 | height = *pp; | ||
287 | |||
288 | pp = (u32 *)get_property(dp, "linux,bootx-linebytes", &len); | ||
289 | if (pp == NULL) | ||
290 | pp = (u32 *)get_property(dp, "linebytes", &len); | ||
291 | if (pp && len == sizeof(u32)) | ||
292 | pitch = *pp; | ||
293 | else | ||
294 | pitch = width * ((depth + 7) / 8); | ||
295 | |||
296 | rsize = (unsigned long)pitch * (unsigned long)height; | ||
297 | |||
298 | /* Ok, now we try to figure out the address of the framebuffer. | ||
299 | * | ||
300 | * Unfortunately, Open Firmware doesn't provide a standard way to do | ||
301 | * so. All we can do is a dodgy heuristic that happens to work in | ||
302 | * practice. On most machines, the "address" property contains what | ||
303 | * we need, though not on Matrox cards found in IBM machines. What I've | ||
304 | * found that appears to give good results is to go through the PCI | ||
305 | * ranges and pick one that is both big enough and if possible encloses | ||
306 | * the "address" property. If none match, we pick the biggest | ||
307 | */ | ||
308 | up = (u32 *)get_property(dp, "linux,bootx-addr", &len); | ||
309 | if (up == NULL) | ||
310 | up = (u32 *)get_property(dp, "address", &len); | ||
311 | if (up && len == sizeof(u32)) | ||
312 | addr_prop = *up; | ||
313 | |||
314 | for (i = 0; (addrp = of_get_address(dp, i, &asize, &flags)) | ||
315 | != NULL; i++) { | ||
316 | int match_addrp = 0; | ||
317 | |||
318 | if (!(flags & IORESOURCE_MEM)) | ||
319 | continue; | ||
320 | if (asize < rsize) | ||
321 | continue; | ||
322 | rstart = of_translate_address(dp, addrp); | ||
323 | if (rstart == OF_BAD_ADDR) | ||
324 | continue; | ||
325 | if (addr_prop && (rstart <= addr_prop) && | ||
326 | ((rstart + asize) >= (addr_prop + rsize))) | ||
327 | match_addrp = 1; | ||
328 | if (match_addrp) { | ||
329 | address = addr_prop; | ||
330 | break; | ||
331 | } | ||
332 | if (rsize > max_size) { | ||
333 | max_size = rsize; | ||
334 | address = OF_BAD_ADDR; | ||
335 | } | ||
336 | |||
337 | if (address == OF_BAD_ADDR) | ||
338 | address = rstart; | ||
339 | } | ||
340 | if (address == OF_BAD_ADDR && addr_prop) | ||
341 | address = (u64)addr_prop; | ||
342 | if (address != OF_BAD_ADDR) { | ||
343 | /* kludge for valkyrie */ | ||
344 | if (strcmp(dp->name, "valkyrie") == 0) | ||
345 | address += 0x1000; | ||
346 | offb_init_fb(dp->name, dp->full_name, width, height, depth, | ||
347 | pitch, address, dp); | ||
348 | } | ||
349 | } | 236 | } |
350 | 237 | ||
351 | static void __init offb_init_fb(const char *name, const char *full_name, | 238 | static void __init offb_init_fb(const char *name, const char *full_name, |
@@ -402,45 +289,39 @@ static void __init offb_init_fb(const char *name, const char *full_name, | |||
402 | 289 | ||
403 | par->cmap_type = cmap_unknown; | 290 | par->cmap_type = cmap_unknown; |
404 | if (depth == 8) { | 291 | if (depth == 8) { |
405 | |||
406 | /* Palette hacks disabled for now */ | 292 | /* Palette hacks disabled for now */ |
407 | #if 0 | ||
408 | if (dp && !strncmp(name, "ATY,Rage128", 11)) { | 293 | if (dp && !strncmp(name, "ATY,Rage128", 11)) { |
409 | unsigned long regbase = dp->addrs[2].address; | 294 | par->cmap_adr = offb_map_reg(dp, 2, 0, 0x1fff); |
410 | par->cmap_adr = ioremap(regbase, 0x1FFF); | 295 | if (par->cmap_adr) |
411 | par->cmap_type = cmap_r128; | 296 | par->cmap_type = cmap_r128; |
412 | } else if (dp && (!strncmp(name, "ATY,RageM3pA", 12) | 297 | } else if (dp && (!strncmp(name, "ATY,RageM3pA", 12) |
413 | || !strncmp(name, "ATY,RageM3p12A", 14))) { | 298 | || !strncmp(name, "ATY,RageM3p12A", 14))) { |
414 | unsigned long regbase = | 299 | par->cmap_adr = offb_map_reg(dp, 2, 0, 0x1fff); |
415 | dp->parent->addrs[2].address; | 300 | if (par->cmap_adr) |
416 | par->cmap_adr = ioremap(regbase, 0x1FFF); | 301 | par->cmap_type = cmap_M3A; |
417 | par->cmap_type = cmap_M3A; | ||
418 | } else if (dp && !strncmp(name, "ATY,RageM3pB", 12)) { | 302 | } else if (dp && !strncmp(name, "ATY,RageM3pB", 12)) { |
419 | unsigned long regbase = | 303 | par->cmap_adr = offb_map_reg(dp, 2, 0, 0x1fff); |
420 | dp->parent->addrs[2].address; | 304 | if (par->cmap_adr) |
421 | par->cmap_adr = ioremap(regbase, 0x1FFF); | 305 | par->cmap_type = cmap_M3B; |
422 | par->cmap_type = cmap_M3B; | ||
423 | } else if (dp && !strncmp(name, "ATY,Rage6", 9)) { | 306 | } else if (dp && !strncmp(name, "ATY,Rage6", 9)) { |
424 | unsigned long regbase = dp->addrs[1].address; | 307 | par->cmap_adr = offb_map_reg(dp, 1, 0, 0x1fff); |
425 | par->cmap_adr = ioremap(regbase, 0x1FFF); | 308 | if (par->cmap_adr) |
426 | par->cmap_type = cmap_radeon; | 309 | par->cmap_type = cmap_radeon; |
427 | } else if (!strncmp(name, "ATY,", 4)) { | 310 | } else if (!strncmp(name, "ATY,", 4)) { |
428 | unsigned long base = address & 0xff000000UL; | 311 | unsigned long base = address & 0xff000000UL; |
429 | par->cmap_adr = | 312 | par->cmap_adr = |
430 | ioremap(base + 0x7ff000, 0x1000) + 0xcc0; | 313 | ioremap(base + 0x7ff000, 0x1000) + 0xcc0; |
431 | par->cmap_data = par->cmap_adr + 1; | 314 | par->cmap_data = par->cmap_adr + 1; |
432 | par->cmap_type = cmap_m64; | 315 | par->cmap_type = cmap_m64; |
433 | } else if (device_is_compatible(dp, "pci1014,b7")) { | 316 | } else if (dp && device_is_compatible(dp, "pci1014,b7")) { |
434 | unsigned long regbase = dp->addrs[0].address; | 317 | par->cmap_adr = offb_map_reg(dp, 0, 0x6000, 0x1000); |
435 | par->cmap_adr = ioremap(regbase + 0x6000, 0x1000); | 318 | if (par->cmap_adr) |
436 | par->cmap_type = cmap_gxt2000; | 319 | par->cmap_type = cmap_gxt2000; |
437 | } | 320 | } |
438 | #endif | 321 | fix->visual = (par->cmap_type != cmap_unknown) ? |
439 | fix->visual = par->cmap_adr ? FB_VISUAL_PSEUDOCOLOR | 322 | FB_VISUAL_PSEUDOCOLOR : FB_VISUAL_STATIC_PSEUDOCOLOR; |
440 | : FB_VISUAL_STATIC_PSEUDOCOLOR; | ||
441 | } else | 323 | } else |
442 | fix->visual = /* par->cmap_adr ? FB_VISUAL_DIRECTCOLOR | 324 | fix->visual = FB_VISUAL_TRUECOLOR; |
443 | : */ FB_VISUAL_TRUECOLOR; | ||
444 | 325 | ||
445 | var->xoffset = var->yoffset = 0; | 326 | var->xoffset = var->yoffset = 0; |
446 | switch (depth) { | 327 | switch (depth) { |
@@ -520,5 +401,139 @@ static void __init offb_init_fb(const char *name, const char *full_name, | |||
520 | info->node, full_name); | 401 | info->node, full_name); |
521 | } | 402 | } |
522 | 403 | ||
404 | |||
405 | static void __init offb_init_nodriver(struct device_node *dp, int no_real_node) | ||
406 | { | ||
407 | unsigned int len; | ||
408 | int i, width = 640, height = 480, depth = 8, pitch = 640; | ||
409 | unsigned int flags, rsize, addr_prop = 0; | ||
410 | unsigned long max_size = 0; | ||
411 | u64 rstart, address = OF_BAD_ADDR; | ||
412 | u32 *pp, *addrp, *up; | ||
413 | u64 asize; | ||
414 | |||
415 | pp = (u32 *)get_property(dp, "linux,bootx-depth", &len); | ||
416 | if (pp == NULL) | ||
417 | pp = (u32 *)get_property(dp, "depth", &len); | ||
418 | if (pp && len == sizeof(u32)) | ||
419 | depth = *pp; | ||
420 | |||
421 | pp = (u32 *)get_property(dp, "linux,bootx-width", &len); | ||
422 | if (pp == NULL) | ||
423 | pp = (u32 *)get_property(dp, "width", &len); | ||
424 | if (pp && len == sizeof(u32)) | ||
425 | width = *pp; | ||
426 | |||
427 | pp = (u32 *)get_property(dp, "linux,bootx-height", &len); | ||
428 | if (pp == NULL) | ||
429 | pp = (u32 *)get_property(dp, "height", &len); | ||
430 | if (pp && len == sizeof(u32)) | ||
431 | height = *pp; | ||
432 | |||
433 | pp = (u32 *)get_property(dp, "linux,bootx-linebytes", &len); | ||
434 | if (pp == NULL) | ||
435 | pp = (u32 *)get_property(dp, "linebytes", &len); | ||
436 | if (pp && len == sizeof(u32)) | ||
437 | pitch = *pp; | ||
438 | else | ||
439 | pitch = width * ((depth + 7) / 8); | ||
440 | |||
441 | rsize = (unsigned long)pitch * (unsigned long)height; | ||
442 | |||
443 | /* Ok, now we try to figure out the address of the framebuffer. | ||
444 | * | ||
445 | * Unfortunately, Open Firmware doesn't provide a standard way to do | ||
446 | * so. All we can do is a dodgy heuristic that happens to work in | ||
447 | * practice. On most machines, the "address" property contains what | ||
448 | * we need, though not on Matrox cards found in IBM machines. What I've | ||
449 | * found that appears to give good results is to go through the PCI | ||
450 | * ranges and pick one that is both big enough and if possible encloses | ||
451 | * the "address" property. If none match, we pick the biggest | ||
452 | */ | ||
453 | up = (u32 *)get_property(dp, "linux,bootx-addr", &len); | ||
454 | if (up == NULL) | ||
455 | up = (u32 *)get_property(dp, "address", &len); | ||
456 | if (up && len == sizeof(u32)) | ||
457 | addr_prop = *up; | ||
458 | |||
459 | /* Hack for when BootX is passing us */ | ||
460 | if (no_real_node) | ||
461 | goto skip_addr; | ||
462 | |||
463 | for (i = 0; (addrp = of_get_address(dp, i, &asize, &flags)) | ||
464 | != NULL; i++) { | ||
465 | int match_addrp = 0; | ||
466 | |||
467 | if (!(flags & IORESOURCE_MEM)) | ||
468 | continue; | ||
469 | if (asize < rsize) | ||
470 | continue; | ||
471 | rstart = of_translate_address(dp, addrp); | ||
472 | if (rstart == OF_BAD_ADDR) | ||
473 | continue; | ||
474 | if (addr_prop && (rstart <= addr_prop) && | ||
475 | ((rstart + asize) >= (addr_prop + rsize))) | ||
476 | match_addrp = 1; | ||
477 | if (match_addrp) { | ||
478 | address = addr_prop; | ||
479 | break; | ||
480 | } | ||
481 | if (rsize > max_size) { | ||
482 | max_size = rsize; | ||
483 | address = OF_BAD_ADDR; | ||
484 | } | ||
485 | |||
486 | if (address == OF_BAD_ADDR) | ||
487 | address = rstart; | ||
488 | } | ||
489 | skip_addr: | ||
490 | if (address == OF_BAD_ADDR && addr_prop) | ||
491 | address = (u64)addr_prop; | ||
492 | if (address != OF_BAD_ADDR) { | ||
493 | /* kludge for valkyrie */ | ||
494 | if (strcmp(dp->name, "valkyrie") == 0) | ||
495 | address += 0x1000; | ||
496 | offb_init_fb(no_real_node ? "bootx" : dp->name, | ||
497 | no_real_node ? "display" : dp->full_name, | ||
498 | width, height, depth, pitch, address, | ||
499 | no_real_node ? dp : NULL); | ||
500 | } | ||
501 | } | ||
502 | |||
503 | static int __init offb_init(void) | ||
504 | { | ||
505 | struct device_node *dp = NULL, *boot_disp = NULL; | ||
506 | |||
507 | if (fb_get_options("offb", NULL)) | ||
508 | return -ENODEV; | ||
509 | |||
510 | /* Check if we have a MacOS display without a node spec */ | ||
511 | if (get_property(of_chosen, "linux,bootx-noscreen", NULL) != NULL) { | ||
512 | /* The old code tried to work out which node was the MacOS | ||
513 | * display based on the address. I'm dropping that since the | ||
514 | * lack of a node spec only happens with old BootX versions | ||
515 | * (users can update) and with this code, they'll still get | ||
516 | * a display (just not the palette hacks). | ||
517 | */ | ||
518 | offb_init_nodriver(of_chosen, 1); | ||
519 | } | ||
520 | |||
521 | for (dp = NULL; (dp = of_find_node_by_type(dp, "display"));) { | ||
522 | if (get_property(dp, "linux,opened", NULL) && | ||
523 | get_property(dp, "linux,boot-display", NULL)) { | ||
524 | boot_disp = dp; | ||
525 | offb_init_nodriver(dp, 0); | ||
526 | } | ||
527 | } | ||
528 | for (dp = NULL; (dp = of_find_node_by_type(dp, "display"));) { | ||
529 | if (get_property(dp, "linux,opened", NULL) && | ||
530 | dp != boot_disp) | ||
531 | offb_init_nodriver(dp, 0); | ||
532 | } | ||
533 | |||
534 | return 0; | ||
535 | } | ||
536 | |||
537 | |||
523 | module_init(offb_init); | 538 | module_init(offb_init); |
524 | MODULE_LICENSE("GPL"); | 539 | MODULE_LICENSE("GPL"); |