Overclock.net banner
61 - 80 of 303 Posts
Discussion starter · #61 · (Edited)
View attachment 2716913

This what you're looking for? Sorry, I'm a bit of a dullard lmao.
I tested your dump and it's the same algorithm so it should work fine. I mean the permanent mod script (interesting that there's some more data past 0xC0 register, but those values aren't considered for CRC. I don't have those 4 extra values, I have 0x0000 instead, might be some random stuff).
Unless someone shows a screenshot with page 0x2A not being available, or the script failing with "page 0x2A not available" message then it works on XTX as well.

So not sure what happened in @~kRon1k~ case.

For anyone else trying this mod, and being curious if it did something or not, just run this Kombustor benchmark: VK Furmark Donut (1080p and 1440p)

Technology Screenshot Electronics Software


With a very high power limit this benchmark insta-redlines my temp limit, 110C in like 2-3 seconds (on my 7800XT using x2 power limit increase). Why I mention you shouldn't raise the limit to very high levels, bump it up 20-30%, see what happens. Then bump it some more until you reach your cooling solution's limits.
 
Oh, so page 0x2a is visible. Did you try running the permanent mod script? It should get you in the menu. You don't need to apply it if you don't want the permanent mods, I'm just curious if you can get to the menu. I'll check the values you dumped but should be same CRC algorithm for sure.
I'll definitely check it out tomorrow.
If you want to fix HWinfo sensors power reporting I did mention how in a previous post. It's helpful to correct that. But I suppose temperatures will give it away you're x1.5 on power limits.
Yep, I actually already did that. It was hitting just over 600W at 1.05V in FurMark. Before it hit the 550W max of the Aqua OC bios at 1.017V. I'd say it is working perfectly 👍. I might push it to 1.2V tomorrow and try to get 3.3-3.4ghz on TS.
 
  • Rep+
Reactions: AndyG and fpsflow
Discussion starter · #63 ·
I'll definitely check it out tomorrow.

Yep, I actually already did that. It was hitting just over 600W at 1.05V in FurMark. Before it hit the 550W max of the Aqua OC bios at 1.017V. I'd say it is working perfectly 👍. I might push it to 1.2V tomorrow and try to get 3.3-3.4ghz on TS.
Thanks for testing! Glad it's working for you.
 
Discussion starter · #64 ·
Managed to remove RDNA4 power limit as well. Atm it's working in ephemeral mode. But seems like it could be permanently saved as well. Didn't yet test permanent save.
Limit is not technically removed, rather increased, to whatever value you want. This is more useful than fully removing it, it helps keep temperatures in check.
I still need to do some more testing, will update the scripts after I'm finished, but atm seems like it's working fine.
 
Discussion starter · #65 · (Edited)
Atm I can only offer some technical info that should help some of you manually remove your RDNA4 limits, for academic purposes 🤓, and I will do it in this post.

The register of interest is at page 1 on both 0x22 and 0x24, namely 0x10. That is Sys Pin (Power In) offset register, and you can alter reported input power. Seems that connector measured current is fed into both VRs, with random split between VRs (didn't get enough samples but from two 9070XT it seems random split between 0x22/0x24, probably depends on GPU model).
From what I could gather on my card, that register is a two's complement value with last bit as sign bit. Similar to VID offset, just that step size seems to be ~11mW in my case (this might vary, could be different on 9070/9060XT).
So values like 0b0000000000000001 (0x0001) would add 11mW to reported power, and values like 0b1111111111111111 (0xFFFF) would remove 11mW from reported power. So 0b1000000000000000 (0x8000) would completely tank the reported Pin value.
But 0x8000 is not ideal as it would completely remove the power limit. Start testing with 0xF000/0xE000/0xD000/0xC000 on both 0x22 and 0x24 at the same time, drop the reported power gradually until you land on a power limit at 100C hotspot or so. This way you have peace of mind your GPU won't get thermally throttled and your die won't degrade in time.

Took a bit of research, and trying various things on Linux. Noticed RDNA4 VRs report a "Pin" value, using mp2856 linux drivers for RDNA4 VRs, and monitoring "sensors" info. The "Pin" reported values were missing from my 7800XT. After monitoring both VRs data, their Pin values seemed to add up to the TBP value that GPU applies the limit on. This was a good breakthrough.

After having played with both 7800XT and 9070XT, I noticed the voltage regulators share similar values, and seem to generally be more similar than different. A random 7800XT VR data dump from Scribd gave me register names, but register addresses were missing for page 1. Luckily I had the same PowerColor 7800XT from that Scribd dump, so I could use my dumped values to reconstruct the register addresses for page 1 of that dump. After doing that, I noticed a Pin offset register name (PIN SYS OFFSET), 0x10 at page 1, and when I tried altering its value it seemed to be what we needed.

There could probably be another way of doing it, but I will not share it at this point, I didn't even test it. I'll keep it for UDNA just in case AMD removes this working method I found.
Would help people who try it share their findings here. Good luck and enjoy, please don't ruin your GPUs.

Also if anyone knows Elmor Labs user maybe they can @ them here, or send them a message or something, so they can include this in their RDNA4 XML. I certainly used their info for RDNA3, it seems only fair they should use my work as well for RDNA4.


If you want to try this, don't, unless you know what you're doing. You need to flip to page 1 on both VRs, and then issue the commands.
 
Which forum or thread specifically? Care to link?
 
I want to move past it, I am just sad I couldn't work with them to prepare a proper working script for everyone, because of **** group politics and big egos. It is what it is.
I appreciate what you're doing. I'm sure many of us do... and a lot of people will in the future. I wouldn't let it phase you. Some people make their knowledge or association with this stuff their whole personality.
 
  • Rep+
Reactions: fpsflow
Discussion starter · #69 · (Edited)
Seems like you might get away with only modifying 0x22 for more power (if most of TBP reporting is on 0x22 Pin), it should be pretty simple and also precise.
We'll take the 330W 9070XT for this example, and suppose you want to add an extra 100W on top of TBP limit.
We start with 0xFFFF which is 0b1111111111111111 (16 1's) and remove the last bit, so we are left with 0b111111111111111 (15 1's), which converted to decimal means 32767.
Now you choose your power limit increase, 100W in this example. Divide 100W by 11mW to get the number of offset steps: 100/0.011=9090. We now subtract this value from 32767, which comes to 23677. We then convert 23677 to binary: 0b101110001111101 (make sure to pad with leading 0's until 15bits long, where the case) and then we add the last bit (1): 0b1101110001111101 (should be 16bit long at this point). Convert this to hex: 0xDC7D. This is the value you write to 0x10 register at page 1. After you do it, your reported TBP will be 100W lower, so you get 100W extra until TBP throttling.
You can also adjust your HWinfo sensors for TBP and TBP limit, this time use additive value and just add the watts value which you increased your TBP by.

For stock cooling go 100-150W tops. You'll probably start thermal throttling higher, or even with 150W extra, depending on your stock cooler.
This assumes 11mW steps, hope it's the same for all 9070XTs. Have no clue if this is the same for 9070.

I managed to get to 315A TDC for GFX, but thermal throttled, so for stock coolers you shouldn't need to increase TDC limit. If you need to, on waterblock or whatever, you should be able to do it like on RDNA3. 0x08 register at page 0x02, same RDNA3 value logic applies.
If you have questions, ask here. If you try increasing TBP on 9070 please report with your results.

If you have a 9060XT, I have no clue about its voltage regulators, which model, how many etc. It might be possible on 9060XT as well, but it's better you run a few commands to find out some data about it, before trying it directly. Ask here and I'll try to help with it.

Example code for extra 100W:
Bash:
i2cset -y 3 0x22 0x00 0x01
i2cset -y 3 0x22 0x10 0xDC7D w
i2cset -y 3 0x22 0x00 0x00
This assumes SMU 0 bus is 3. Might be 0 on usb live boot, like CachyOS.

To remove the TBP offset just power off your PC, or write 0x0000 back, to 0x10 register on page 1:

Bash:
i2cset -y 3 0x22 0x00 0x01
i2cset -y 3 0x22 0x10 0x0000 w
i2cset -y 3 0x22 0x00 0x00
Permanent save of this offset could be possible, I have not yet tested it, nor permanent VID offsets save.
Ah yes, this might give a maximum of x2 power increase, but 725W-750W should be plenty for most things. I wasn't able to get too high with stock cooler, so yet to understand its behavior/max limits. You clearly need to add the offset to both 0x22 and 0x24 for maximum power limit increase.

Disclaimer as usual: you do this at your own risk, this can break/brick/burn your GPU. Do not try to skirt warranty claims. AMD might know you modified your power limit. EEPROM pages are fully inaccessible on RDNA4, so I have no idea if/what gets saved on it, errors, power limit increase etc, so assume your warranty is void by doing any of these mods to your VRs. I am not responsible for anything you do.
 
Discussion starter · #70 · (Edited)
I have just tested permanent save and seems to work fine, for both VID and power level offsets. Pretty simple to do as well, just issue 0x15 write command after setting the offsets.

The 11mW step could be valid for 330W official limits 9070XT's. The actual math might be with max TDP, which contains extra 10% on top of default limit: 330*1.1=363W, and we divide this by 2^15 so 363/2^15=0.0110778W/LSB. So 11.07mW, could probably use 11.1mW instead.
For 340W default limit 374/2^15=0.011413W/LSB, so try 11.4mW instead, that may more precisely predict the power level increase.
Same for 9070, for 265W max TDP 265/2^15=8.087mW. Try it with your GPU official limits, might be more precise this way, instead of using 11mW like in my case.
 
Discussion starter · #71 ·
There could probably be another way of doing it, but I will not share it at this point, I didn't even test it. I'll keep it for UDNA just in case AMD removes this working method I found.
As I said, there might be another way of doing it, which ideally we'd save for UDNA, just in case this one goes away, because it became known at this point, so AMD could close it in the future.
I hope the alternative is not revealed, out of all kinds of reasons. The reason I decided to use this one is because it's pretty simple to use and does the job just fine, and can be permanently saved. Hope others I shared the method with don't just burn another possible solution for UDNA, with no real reason whatsoever, when we already have a working one.
That would be just bad management.
 
Discussion starter · #72 · (Edited)
I made a few precise tests and seems there's no change for bits 0-7. Only bits 8 to 14, so 7 bits total for Pin offset. A bit strange for only 128 values but seems like it.
I have the same jump from 0x00ff to 0xff00 like I have from 0x0000 to 0xffff, about 2-3W offset.

I made a test script to decrement from 0xff00 (0b1111111100000000) to 0x8000 (0b1000000000000000) and the offset seems to be linear, going through the 128 values:

Number Font Screenshot Software Technology


Also from what I could tell, most predictable results are when I divide 374W by 128. So 340W+10%. Could be related to TDP value from power play table, which would make it simpler for my script, I could read the value for the GPU (should work for any 9070xt/9070 if this holds true), user would only have to input the desired power increase value, like +100W or whatever.
So I don't think it's a W/LSB thing, rather 0.78125%/LSB, out of max TDP from power play table. Still not sure but looks like it.

For the test in the above photo I used this code:
Bash:
#!/bin/bash

# Start with 0xff00 (0b1111111100000000) and end at 0x8000 (0b1000000000000000)
start=255  # which is the upper 8 bits of 0xff00
end=128    # which is the upper 8 bits of 0x8000

# Loop from start to end, decrementing by 1 each time
for ((i=start; i>=end; i--)); do
    value=$(( (i << 8) & 0xff00 ))
    hex=$(printf "0x%04x\n" "$value")
    echo -e "$hex"
    i2cset -y 0 0x22 0x10 "$hex" w
    sleep 0.4
done
Make sure you change to page 0x01 on 0x22 VR before running this script, if you want to run the same test.


I looked at HWinfo data, and seems that TBP is made up from "GPU Core Input Power" + "GPU SoC Input Power". These two should be Pin from 0x22 and 0x24, they seem to add up to TBP total value:
Font Screenshot


And adding an offset to 0x22 Pin affects these values from HWinfo:
Font Screenshot

So you could add the offset difference to each, to get back the real values, or reflect new TBP limit.
If you add an offset to 0x22 or 0x24 Pin, the respective sensor will disappear from HWinfo, until it reports >0W value (with offset included, so with 100W offset you need more than 100W load on that sensor to get it back), then it reappears in the list. So if you don't see it, start a load and it will pop back and stay.

The RDNA4 script is coming along nicely, but will take a bit more until it's ready.
 
Discussion starter · #76 ·
Has this not helped?
No, it's also wrong I think, bits 0 to 7 don't seem to do anything (at least so far, on my GPU) and bits 8 to 14 affect both Pin and Iin for VRs. Since I am building the RDNA4 script I have to do more in depth testing for more precise adjustments.

I would appreciate if you would stop helping, or associating yourself with my project. Or post in my thread here. Your help is not needed.
Thank you.
 
No, it's also wrong I think
Bitfields [7-0] and [15-8] do exactly what I described in that post, that is applying offset to Pin and Iin given the specified scale.
I would appreciate if you would stop helping, or associating yourself with my project. Or post in my thread here. Your help is not needed.
Thank you.
Ah... nice way to express appreciation, You're welcome anyway ))
 
Discussion starter · #78 ·
I tested something which I was curious of, if we can use TDC limit throttling, just in case precise TBP offset is not possible. TBP being split between the two VRs, my script only alters 0x22 VR, which seems to have the bulk of it.
If this split between VRs Pin varies a lot from GPU to GPU, it would make precise adjustment more complicated. In which case I added an option in the RDNA4 script to basically double TBP by altering both VRs Pin value to maximum that is allowed, thus allowing for x2 TBP limit increase on probably all 9070/XT GPUs.

In this case, we'd most likely thermal throttle under some loads, but we can use TDC_GFX limit to set a power limit, basically like RDNA3 does. Could be useful to still have a limit before hotspot getting too high.

Technology Electronics Screenshot


Here I altered 0x08 register at page 2 on 0x22 VR, current gain value, I adjusted it the other way vs RDNA3, I doubled it, which decreased TDC_GFX limit from 330A to probably 165A. I then set it back to stock value, can be seen on graph output power level increased back.

Atm the script allows only for increasing TDC_GFX limit, but I can make it go the other way, if we need to use this method for having a limit before thermal throttling, it seems to be working fine.
 
Discussion starter · #79 · (Edited)
RDNA4 Script Beta Release

I've finished development of the RDNA4 script and am releasing it as a beta. Testing has been limited to my GPU so far.

Disclaimer:

This script is intended for academic and research purposes only. Using it on your GPU may void your warranty. I am not responsible for any damage or failure that occurs as a result of using this script. You assume full responsibility for your actions and any consequences they may have. Modifying the manufacturer’s operating conditions of your GPU carries inherent risk.

Overview:

This script provides both ephemeral (temporary) and permanent modification options, in contrast to the RDNA3 version which required separate scripts for each type of change. It’s currently tested on my GPU and should work with the 9070XT and 9070, and potentially even the 9060XT. I've examined teardowns of several 9060XT cards and they appear to use the same MP2868A VRs as the higher-end models (two of them). Rail allocation may differ, but the core VR components seem to be consistent. The VRAM rail appears to be connected to the second VR, similar to the 9070/XT setup.

Functionality:

The script allows you to alter TBP/TDC limits, and also apply VID offsets. Only power limits and VID offsets can be permanently saved. The TDC limit modification currently works only in ephemeral mode and resets to stock values after a full power cycle. I'm working on making the TDC mod permanent, but some information is currently missing. A permanent TDC limit alteration isn't as critical, as you’ll likely hit the hotspot limit before reaching the TDC limit of 330A on stock cooling.

You can increase or decrease the TDC limit. Lowering it can be useful as a safety measure if you increase the TBP significantly, providing an adjustable limit to prevent thermal throttling.

Running the Script:

To run the script first run "chmod +x rdna4.sh" and then run it with "./rdna4.sh". Make sure you have internet access so script can pull i2c-tools or bc packages, if they are missing.

The script can be run in two modes:

1. Direct Mode: This mode reads user-saved values from the script file at the beginning, automatically applies them in ephemeral mode, and then exits. This is convenient if you don’t want to spend time in the menu or make permanent changes – just run presets and reboot to Windows.
2. Menu Mode: Start the script with the -m switch to access the menu (run "./rdna4.sh -m"):

Text Font Screenshot Number Software


Option 1: TBP/TDC Limits Menu

Font Screenshot Number Software Multimedia


In this menu, option 1 applies a preset TDC limit increase. Option 2 allows you to set a custom scaling factor, ranging from 0.10 to 2.00. Values below 1.00 lower the TDC limit, and higher values increase it.

RDNA4 GPUs have a stock TDC limit of 330A for the graphics processor (GFX). VRM capacity typically ranges from 8 rails at 50A (lowest values, totaling 400A), up to 600A on some GPUs. A multiplier of x1.20 increases the limit from 330A to ~400A, and x1.80 increases it to ~600A. x0.50 reduces the limit to 165A.

There may be a minimum TDC limit achievable, dependent on the stock value present in your VR configuration. This seems to vary from GPU to GPU. You can safely try a multiplier as low as x0.10, the max value script is going to write in that register is 2047 (full 11bit value).

You can precisely calculate the desired TDC limit using this formula: desired_TDC (in amps) / 330A = scaling value. This scaling value can also be used to correct TDC_GFX reporting in HWinfo.

Option 3 directly applies a preset TBP limit increase (x1.3 default). Yellow value is calculated based on the maximum power level your GPU supports (read from a sys file in Linux OS) + any already present offset. The x1.3 default I set (green 486W in above photo) should be safe for stock cooling and gaming purposes.

Option 4 allows you to set a custom TBP limit (replace the 486W preset in above photo), which you then apply with option 3.

Option 5 maximizes the limits on both VRs. Options 3-4 modify the 0x22 GFX VR by altering the Pin value to increase the power limit. Option 5 applies the maximum offset to both 0x22 and 0x24 VRs, effectively representing a “max power” setting.

Option 6 removes any power limit offset.

VID Offsets Menu

Screenshot Font Number


Here, each option allows you to set a VID offset in millivolts (mV) with a positive or negative sign. It’s relatively self-explanatory.

On the main menu, there are two more options:

* Option 3: Permanently Save Mods: This writes the current values to the EEPROM, making the changes permanent.
* Option 4: Restore Stock Values: This reverts the values to their factory defaults, and also writes them to EEPROM.

Use these options sparingly, as they involve actual writes to the EEPROM. Test temporary mods thoroughly before making them permanent.

Script Behavior with No Saved Values:

If you run the script without the -m switch and no values are saved in the file, the script will behave as follows:

Font Screenshot Number


I recommend running the script once in this mode to check the GFX_VID. Some GPUs have a factory +5mV offset for some reason. For example, Buildzoid’s 9070 has a +5mV offset on GFX. Note this value, as you may need to add it back if you restore to factory settings after making permanent modifications. The script sets 0mV VID offsets for all four rails. Therefore, if your GPU has a factory offset, you’ll need to re-apply it to maintain the stock configuration.

Setting Custom Values:

Number Screenshot Software Display device Multimedia


This is where you can set your custom values to be automatically applied every time you run the script without the -m switch:

user_tbp_increase_vr1 takes a value in watts and applies it as an offset to the GPU Core Input Power sensor from HWinfo. user_tbp_increase_vr2 applies the offset to the GPU SoC Input Power sensor. Both these sensors add up to the TBP value you can also find in HWinfo. Altering these two Input Power values alters TBP, thus allowing for more power. There seems to be a random split of TBP between GPU/SoC VRs for various GPUs, so with user_tbp_increase_vr1/2 you can selectively apply an offset on each of them depending on the power split on your GPU. Basically allows for more granularity for setting the max power limit.

Usually, you’ll only need to use user_tbp_increase_vr1, as the bulk of power is reported on GPU Core Input Power. Adding 100 or 150 for a 100W or 150W power limit increase should be fine for gaming.

user_current_gain_multiplier is the TDC limit multiplier.

The rest are VID offset values – use +20 for a +20mV offset or -5 for a -5mV offset, for example.

You can leave the ones you don’t intend to use blank. So, for example, you can just add 100 for user_tbp_increase_vr1 and +80 for user_vid_offset_vram (for Samsung VRAM, which goes to 2900MHz with +80mV VID offset), and you're set for gaming.

You can also run the script once with your custom values without the -m switch to make them active, then run the script again with -m to access the menu and permanently save them using option 3 from the main menu.

If you have custom values saved in the script file and run the script with -m, they won’t be applied – you’ll just get the menu. They apply only if the -m switch is not used.

Download Link:


Testing and Feedback:

This is a beta release, so please report any issues or feedback you encounter.

Disclaimer: Again, use at your own risk.

edit: Small chance TBP limit increase doesn't work on some GPUs, if you notice that do mention here, I have a potential fix ready. As it is now, the script does fully work on my GPU, tested all options and I confirmed them working as intended.

Also check this post on how to practically check if your limits actually increased:
Do not expect HWinfo/AMD interface to report a higher TBP limit. The trick the script pulls is make the voltage regulator under-report the power usage. For example you add 100W on top of power limit by making the VR under-report the total power consumption by 100W. So at same 374W reported power, where GPU throttles, you will actually have 474W, just that OS/GPU/HWinfo won't reflect this, only clues about it, increased junction temps, higher operating clocks etc. Or just check with a socket power meter.
 
Hello @fpsflow, first of all, thank you very much for your work!

I tried running your script to increase the TBP on my 9070 XT XFX Mercury, but unfortunately as you mentioned in your earlier post it doesn’t work.

The third option shows my TBP limit as 0W, and when I try to increase the limit using the fourth option, it says something like "you can't increase the limit twice."


Maybe I'm doing something wrong ?
 
61 - 80 of 303 Posts