mmc: dw_mmc: Allow lower TMOUT value than maximum
Subsystems (2)
PATCH v4 1/1 mmc: dw_mmc: Allow lower TMOUT value than maximum
The TMOUT register is always set with a full value for every transfer, which (with a 200MHz clock) will give a full DRTO of ~84 milliseconds. This is normally good enough to complete the request, but setting a full value makes it impossible to test shorter timeouts, when for example testing data read times on different SD cards.
Add a function to set any value smaller than the maximum of 0xFFFFFF.
---
v2:
- Calculate new value before checking boundaries
- Include CLKDIV register to get proper value
v3:
- Use 'if-else' instead of 'goto'
- Don't touch response field when maximize data field
v4:
- Prevent 32bit divider overflow by splitting the operation
- Changed %06x to %#08x as suggested by Doug
- Rephrased commit msg as suggested by Doug
drivers/mmc/host/dw_mmc.c | 28 +++++++++++++++++++++++++++- 1 file changed, 27 insertions(+), 1 deletion(-)
drivers/mmc/host/dw_mmc.c +27 -1
@@ -1283,6 +1283,32 @@ static void dw_mci_setup_bus(struct dw_mci_slot *slot, bool force_clkinit)mci_writel (host,CTYPE , (slot->ctype << slot->id)); } +static void dw_mci_set_data_timeout (struct dw_mci *host, +unsigned int timeout_ns) +{ +unsigned int clk_div, tmp, tmout; + + clk_div = (mci_readl (host,CLKDIV ) &0xFF ) *2 ; +if (clk_div ==0 ) + clk_div =1 ; + + tmp =DIV_ROUND_UP_ULL ((u64 )timeout_ns * host->bus_hz,NSEC_PER_SEC ); + tmp =DIV_ROUND_UP (tmp, clk_div); + +/* TMOUT[7:0] (RESPONSE_TIMEOUT) */ + tmout =0xFF ;/* Set maximum */ + +/* TMOUT[31:8] (DATA_TIMEOUT) */ +if (!tmp || tmp >0xFFFFFF ) + tmout |= (0xFFFFFF <<8 ); +else + tmout |= (tmp &0xFFFFFF ) <<8 ; + +mci_writel (host,TMOUT , tmout); +dev_dbg (host->dev,"timeout_ns: %u => TMOUT[31:8]: 0x%#08x" , + timeout_ns, tmout >>8 ); +} +static void __dw_mci_start_request (struct dw_mci *host,struct dw_mci_slot *slot,struct mmc_command *cmd)
@@ -1303,7 +1329,7 @@ static void __dw_mci_start_request(struct dw_mci *host, data = cmd->data;if (data) { -mci_writel (host,TMOUT ,0xFFFFFFFF ); +dw_mci_set_data_timeout (host, data->timeout_ns);mci_writel (host,BYTCNT , data->blksz*data->blocks);mci_writel (host,BLKSIZ , data->blksz); }
Signature · 1 line
2.20.1
Hi,
Quoted 33 lines · Mårten Lindahl
The TMOUT register is always set with a full value for every transfer, which (with a 200MHz clock) will give a full DRTO of ~84 milliseconds. This is normally good enough to complete the request, but setting a full value makes it impossible to test shorter timeouts, when for example testing data read times on different SD cards.
Add a function to set any value smaller than the maximum of
0xFFFFFF.Signed-off-by Mårten Lindahl <[email protected]>---
v2:
- Calculate new value before checking boundaries
- Include CLKDIV register to get proper valuev3:
- Use 'if-else' instead of 'goto'
- Don't touch response field when maximize data fieldv4:
- Prevent 32bit divider overflow by splitting the operation
- Changed %06x to %#08x as suggested by Doug
- Rephrased commit msg as suggested by Dougdrivers/mmc/host/dw_mmc.c | 28 +++++++++++++++++++++++++++- 1 file changed, 27 insertions(+), 1 deletion(-)drivers/mmc/host/dw_mmc.c +0
-0
drivers/mmc/host/dw_mmc.c static void dw_mci_setup_bus(struct dw_mci_slot *slot, bool force_clkinit) · line 1289
Quoted 7 lines
drivers/mmc/host/dw_mmc.c +4
-0@@ -1283,6 +1283,32 @@ static void dw_mci_setup_bus(struct dw_mci_slot *slot, bool force_clkinit)mci_writel (host,CTYPE , (slot->ctype << slot->id)); } +static void dw_mci_set_data_timeout (struct dw_mci *host, +unsigned int timeout_ns) +{ +unsigned int clk_div, tmp, tmout;
didn't notice before, but nit that I usually make it a policy that things that represent cpu registers are the "sized" types. Thus I'd rather see these locals as u32 even though the parameter (which represents a logical value and not a CPU register) stays as "unsigned int").
drivers/mmc/host/dw_mmc.c static void dw_mci_setup_bus(struct dw_mci_slot *slot, bool force_clkinit) · line 1296
Quoted 6 lines
drivers/mmc/host/dw_mmc.c +6
-0+ clk_div = (mci_readl (host,CLKDIV ) &0xFF ) *2 ; +if (clk_div ==0 ) + clk_div =1 ; + + tmp =DIV_ROUND_UP_ULL ((u64 )timeout_ns * host->bus_hz,NSEC_PER_SEC ); + tmp =DIV_ROUND_UP (tmp, clk_div);
I guess in some extreme cases you still have an overflow. Not sure how many people really use "div", but...
The case I'm thinking of is if the timeout is 80 ms, the bus_hz is 200 MHz, and clk_div is 20 (register contains 10). I think that would mean you're feeding the controller a 4GHz clock which it probably couldn't _really_ handle, so maybe this isn't super realistic. In any case, I think the first statement would be the equivalent of 80 * 200MHz = 0x3b9aca000 and that blows out the 32-bit "tmp" variable.
Why not just keep it as 64-bit until you're done dividing to be safe?
-Doug
On Thu, Nov 18, 2021 at 12:29:46AM +0100, Doug Anderson wrote:
Hi Doug!
Quoted 39 lines
Hi,
Quoted 36 lines · Mårten Lindahl
The TMOUT register is always set with a full value for every transfer, which (with a 200MHz clock) will give a full DRTO of ~84 milliseconds. This is normally good enough to complete the request, but setting a full value makes it impossible to test shorter timeouts, when for example testing data read times on different SD cards.
Add a function to set any value smaller than the maximum of
0xFFFFFF.Signed-off-by Mårten Lindahl <[email protected]>---
v2:
- Calculate new value before checking boundaries
- Include CLKDIV register to get proper valuev3:
- Use 'if-else' instead of 'goto'
- Don't touch response field when maximize data fieldv4:
- Prevent 32bit divider overflow by splitting the operation
- Changed %06x to %#08x as suggested by Doug
- Rephrased commit msg as suggested by Dougdrivers/mmc/host/dw_mmc.c | 28 +++++++++++++++++++++++++++- 1 file changed, 27 insertions(+), 1 deletion(-)drivers/mmc/host/dw_mmc.c +0
-0@@ -1283,6 +1283,32 @@ static void dw_mci_setup_bus(struct dw_mci_slot *slot, bool force_clkinit)mci_writel (host,CTYPE , (slot->ctype << slot->id)); }
Quoted 11 lines
drivers/mmc/host/dw_mmc.c static void dw_mci_setup_bus(struct dw_mci_slot *slot, bool force_clkinit) · line 1289
Quoted 4 lines
drivers/mmc/host/dw_mmc.c +4
-0+static void dw_mci_set_data_timeout (struct dw_mci *host, +unsigned int timeout_ns) +{ +unsigned int clk_div, tmp, tmout;didn't notice before, but nit that I usually make it a policy that things that represent cpu registers are the "sized" types. Thus I'd rather see these locals as u32 even though the parameter (which represents a logical value and not a CPU register) stays as "unsigned int").
Thanks, will fix.
Quoted 11 lines
drivers/mmc/host/dw_mmc.c static void dw_mci_setup_bus(struct dw_mci_slot *slot, bool force_clkinit) · line 1296
Quoted 7 lines
drivers/mmc/host/dw_mmc.c +6
-0+ clk_div = (mci_readl (host,CLKDIV ) &0xFF ) *2 ; +if (clk_div ==0 ) + clk_div =1 ; + + tmp =DIV_ROUND_UP_ULL ((u64 )timeout_ns * host->bus_hz,NSEC_PER_SEC ); + tmp =DIV_ROUND_UP (tmp, clk_div);I guess in some extreme cases you still have an overflow. Not sure how many people really use "div", but...
Quoted 6 lines
The case I'm thinking of is if the timeout is 80 ms, the
bus_hzis 200 MHz, andclk_divis 20 (register contains 10). I think that would mean you're feeding the controller a 4GHz clock which it probably couldn't _really_ handle, so maybe this isn't super realistic. In any case, I think the first statement would be the equivalent of 80 * 200MHz =0x3b9aca000and that blows out the 32-bit "tmp" variable.
I'm sorry but I fail to follow your calculation here. With 80ms timeout and 200MHz bus_hz, I get:
80000000 * 200000000 / 1000000000 = 0xF42400
The only way I manage to get an overflow of tmp is with:
timeout = INT_MAX * bus_hz = (value greater than 1000000000) / 1000000000
So my reasoning is that tmp = DIV_ROUND_UP(tmp, clk_div) is safe within these values, but I can of course make tmp an unsigned long, and in that case do the clk_div division as:
tmp = DIV_ROUND_UP_ULL(tmp, clk_div)
Kind regards
Mårten
Quoted 4 lines
Why not just keep it as 64-bit until you're done dividing to be safe?
-Doug
Hi,
Quoted 76 lines · Marten Lindahl
On Thu, Nov 18, 2021 at 12:29:46AM +0100, Doug Anderson wrote:
Hi Doug!
Quoted 39 lines
Hi,
Quoted 36 lines · Mårten Lindahl
The TMOUT register is always set with a full value for every transfer, which (with a 200MHz clock) will give a full DRTO of ~84 milliseconds. This is normally good enough to complete the request, but setting a full value makes it impossible to test shorter timeouts, when for example testing data read times on different SD cards.
Add a function to set any value smaller than the maximum of
0xFFFFFF.Signed-off-by Mårten Lindahl <[email protected]>---
v2:
- Calculate new value before checking boundaries
- Include CLKDIV register to get proper valuev3:
- Use 'if-else' instead of 'goto'
- Don't touch response field when maximize data fieldv4:
- Prevent 32bit divider overflow by splitting the operation
- Changed %06x to %#08x as suggested by Doug
- Rephrased commit msg as suggested by Dougdrivers/mmc/host/dw_mmc.c | 28 +++++++++++++++++++++++++++- 1 file changed, 27 insertions(+), 1 deletion(-)drivers/mmc/host/dw_mmc.c +0
-0@@ -1283,6 +1283,32 @@ static void dw_mci_setup_bus(struct dw_mci_slot *slot, bool force_clkinit)mci_writel (host,CTYPE , (slot->ctype << slot->id)); }Quoted 11 lines
drivers/mmc/host/dw_mmc.c static void dw_mci_setup_bus(struct dw_mci_slot *slot, bool force_clkinit) · line 1289
Quoted 4 lines
drivers/mmc/host/dw_mmc.c +4
-0+static void dw_mci_set_data_timeout (struct dw_mci *host, +unsigned int timeout_ns) +{ +unsigned int clk_div, tmp, tmout;didn't notice before, but nit that I usually make it a policy that things that represent cpu registers are the "sized" types. Thus I'd rather see these locals as u32 even though the parameter (which represents a logical value and not a CPU register) stays as "unsigned int").
Thanks, will fix.
Quoted 11 lines
drivers/mmc/host/dw_mmc.c static void dw_mci_setup_bus(struct dw_mci_slot *slot, bool force_clkinit) · line 1296
Quoted 7 lines
drivers/mmc/host/dw_mmc.c +6
-0+ clk_div = (mci_readl (host,CLKDIV ) &0xFF ) *2 ; +if (clk_div ==0 ) + clk_div =1 ; + + tmp =DIV_ROUND_UP_ULL ((u64 )timeout_ns * host->bus_hz,NSEC_PER_SEC ); + tmp =DIV_ROUND_UP (tmp, clk_div);I guess in some extreme cases you still have an overflow. Not sure how many people really use "div", but...
Quoted 6 lines
The case I'm thinking of is if the timeout is 80 ms, the
bus_hzis 200 MHz, andclk_divis 20 (register contains 10). I think that would mean you're feeding the controller a 4GHz clock which it probably couldn't _really_ handle, so maybe this isn't super realistic. In any case, I think the first statement would be the equivalent of 80 * 200MHz =0x3b9aca000and that blows out the 32-bit "tmp" variable.
Quoted 4 lines
I'm sorry but I fail to follow your calculation here. With 80ms timeout and 200MHz
bus_hz, I get:80000000 * 200000000 / 1000000000 =
0xF42400
Sorry, it's just my brain not working properly. Yeah, I think you were fine assuming it was 32-bit. It seems terribly unlikely that bus_hz could be anywhere approaching 32-bit max. Even if it was, the timeout is documented to be max on the order of 80 ms:
/* data timeout (in ns, max 80ms) */
...and even if that's wrong and it's 800 ms _and_ bus_hz is the absurdly large 0xffffffff then we still don't timeout.
Sorry for getting that wrong. :(
-Doug
Quoted 89 lines · Doug Anderson
Hi,
Quoted 76 lines · Marten Lindahl
On Thu, Nov 18, 2021 at 12:29:46AM +0100, Doug Anderson wrote:
Hi Doug!
Quoted 39 lines
Hi,
Quoted 36 lines · Mårten Lindahl
The TMOUT register is always set with a full value for every transfer, which (with a 200MHz clock) will give a full DRTO of ~84 milliseconds. This is normally good enough to complete the request, but setting a full value makes it impossible to test shorter timeouts, when for example testing data read times on different SD cards.
Add a function to set any value smaller than the maximum of
0xFFFFFF.Signed-off-by Mårten Lindahl <[email protected]>---
v2:
- Calculate new value before checking boundaries
- Include CLKDIV register to get proper valuev3:
- Use 'if-else' instead of 'goto'
- Don't touch response field when maximize data fieldv4:
- Prevent 32bit divider overflow by splitting the operation
- Changed %06x to %#08x as suggested by Doug
- Rephrased commit msg as suggested by Dougdrivers/mmc/host/dw_mmc.c | 28 +++++++++++++++++++++++++++- 1 file changed, 27 insertions(+), 1 deletion(-)drivers/mmc/host/dw_mmc.c +0
-0@@ -1283,6 +1283,32 @@ static void dw_mci_setup_bus(struct dw_mci_slot *slot, bool force_clkinit)mci_writel (host,CTYPE , (slot->ctype << slot->id)); }Quoted 11 lines
drivers/mmc/host/dw_mmc.c static void dw_mci_setup_bus(struct dw_mci_slot *slot, bool force_clkinit) · line 1289
Quoted 4 lines
drivers/mmc/host/dw_mmc.c +4
-0+static void dw_mci_set_data_timeout (struct dw_mci *host, +unsigned int timeout_ns) +{ +unsigned int clk_div, tmp, tmout;didn't notice before, but nit that I usually make it a policy that things that represent cpu registers are the "sized" types. Thus I'd rather see these locals as u32 even though the parameter (which represents a logical value and not a CPU register) stays as "unsigned int").
Thanks, will fix.
Quoted 11 lines
drivers/mmc/host/dw_mmc.c static void dw_mci_setup_bus(struct dw_mci_slot *slot, bool force_clkinit) · line 1296
Quoted 7 lines
drivers/mmc/host/dw_mmc.c +6
-0+ clk_div = (mci_readl (host,CLKDIV ) &0xFF ) *2 ; +if (clk_div ==0 ) + clk_div =1 ; + + tmp =DIV_ROUND_UP_ULL ((u64 )timeout_ns * host->bus_hz,NSEC_PER_SEC ); + tmp =DIV_ROUND_UP (tmp, clk_div);I guess in some extreme cases you still have an overflow. Not sure how many people really use "div", but...
Quoted 6 lines
The case I'm thinking of is if the timeout is 80 ms, the
bus_hzis 200 MHz, andclk_divis 20 (register contains 10). I think that would mean you're feeding the controller a 4GHz clock which it probably couldn't _really_ handle, so maybe this isn't super realistic. In any case, I think the first statement would be the equivalent of 80 * 200MHz =0x3b9aca000and that blows out the 32-bit "tmp" variable.Quoted 4 lines
I'm sorry but I fail to follow your calculation here. With 80ms timeout and 200MHz
bus_hz, I get:80000000 * 200000000 / 1000000000 =
0xF42400Sorry, it's just my brain not working properly. Yeah, I think you were fine assuming it was 32-bit. It seems terribly unlikely that
bus_hzcould be anywhere approaching 32-bit max. Even if it was, the timeout is documented to be max on the order of 80 ms:
Quoted 6 lines
/* data timeout (in ns, max 80ms) */
...and even if that's wrong and it's 800 ms _and_
bus_hzis the absurdly large0xffffffffthen we still don't timeout.Sorry for getting that wrong. :(
No problem. Reviews are for twisting and turning the code.
To twist it even more, there is no real need to use DIV_ROUND_UP(_ULL) on the clkdiv division right? I mean the round up has already been made, and it shouldn't be needed twice?
So,
tmp = DIV_ROUND_UP_(ULL)(tmp, clk_div);
could be a
tmp /= clk_div;
Kind regards
Mårten
Quoted 2 lines
-Doug
Hi,
Quoted 104 lines · Marten Lindahl
Quoted 89 lines · Doug Anderson
Hi,
Quoted 76 lines · Marten Lindahl
On Thu, Nov 18, 2021 at 12:29:46AM +0100, Doug Anderson wrote:
Hi Doug!
Quoted 39 lines
Hi,
Quoted 36 lines · Mårten Lindahl
The TMOUT register is always set with a full value for every transfer, which (with a 200MHz clock) will give a full DRTO of ~84 milliseconds. This is normally good enough to complete the request, but setting a full value makes it impossible to test shorter timeouts, when for example testing data read times on different SD cards.
Add a function to set any value smaller than the maximum of
0xFFFFFF.Signed-off-by Mårten Lindahl <[email protected]>---
v2:
- Calculate new value before checking boundaries
- Include CLKDIV register to get proper valuev3:
- Use 'if-else' instead of 'goto'
- Don't touch response field when maximize data fieldv4:
- Prevent 32bit divider overflow by splitting the operation
- Changed %06x to %#08x as suggested by Doug
- Rephrased commit msg as suggested by Dougdrivers/mmc/host/dw_mmc.c | 28 +++++++++++++++++++++++++++- 1 file changed, 27 insertions(+), 1 deletion(-)drivers/mmc/host/dw_mmc.c +0
-0@@ -1283,6 +1283,32 @@ static void dw_mci_setup_bus(struct dw_mci_slot *slot, bool force_clkinit)mci_writel (host,CTYPE , (slot->ctype << slot->id)); }Quoted 11 lines
drivers/mmc/host/dw_mmc.c static void dw_mci_setup_bus(struct dw_mci_slot *slot, bool force_clkinit) · line 1289
Quoted 4 lines
drivers/mmc/host/dw_mmc.c +4
-0+static void dw_mci_set_data_timeout (struct dw_mci *host, +unsigned int timeout_ns) +{ +unsigned int clk_div, tmp, tmout;didn't notice before, but nit that I usually make it a policy that things that represent cpu registers are the "sized" types. Thus I'd rather see these locals as u32 even though the parameter (which represents a logical value and not a CPU register) stays as "unsigned int").
Thanks, will fix.
Quoted 11 lines
drivers/mmc/host/dw_mmc.c static void dw_mci_setup_bus(struct dw_mci_slot *slot, bool force_clkinit) · line 1296
Quoted 7 lines
drivers/mmc/host/dw_mmc.c +6
-0+ clk_div = (mci_readl (host,CLKDIV ) &0xFF ) *2 ; +if (clk_div ==0 ) + clk_div =1 ; + + tmp =DIV_ROUND_UP_ULL ((u64 )timeout_ns * host->bus_hz,NSEC_PER_SEC ); + tmp =DIV_ROUND_UP (tmp, clk_div);I guess in some extreme cases you still have an overflow. Not sure how many people really use "div", but...
Quoted 6 lines
The case I'm thinking of is if the timeout is 80 ms, the
bus_hzis 200 MHz, andclk_divis 20 (register contains 10). I think that would mean you're feeding the controller a 4GHz clock which it probably couldn't _really_ handle, so maybe this isn't super realistic. In any case, I think the first statement would be the equivalent of 80 * 200MHz =0x3b9aca000and that blows out the 32-bit "tmp" variable.Quoted 4 lines
I'm sorry but I fail to follow your calculation here. With 80ms timeout and 200MHz
bus_hz, I get:80000000 * 200000000 / 1000000000 =
0xF42400Sorry, it's just my brain not working properly. Yeah, I think you were fine assuming it was 32-bit. It seems terribly unlikely that
bus_hzcould be anywhere approaching 32-bit max. Even if it was, the timeout is documented to be max on the order of 80 ms:Quoted 6 lines
/* data timeout (in ns, max 80ms) */
...and even if that's wrong and it's 800 ms _and_
bus_hzis the absurdly large0xffffffffthen we still don't timeout.Sorry for getting that wrong. :(
No problem. Reviews are for twisting and turning the code.
To twist it even more, there is no real need to use
DIV_ROUND_UP(_ULL)on the clkdiv division right? I mean the round up has already been made, and it shouldn't be needed twice?
Quoted 6 lines
So,
tmp = DIV_ROUND_UP_(ULL)(tmp, clk_div);could be a
tmp /= clk_div;
I think you still need the round up, but I wouldn't swear to it. You've divided by one value, but not the other and each division could separately need rounding.
-Doug
Quoted 110 lines · Doug Anderson
Hi,
Quoted 107 lines · Marten Lindahl
Quoted 89 lines · Doug Anderson
Hi,
Quoted 76 lines · Marten Lindahl
On Thu, Nov 18, 2021 at 12:29:46AM +0100, Doug Anderson wrote:
Hi Doug!
Quoted 39 lines
Hi,
Quoted 36 lines · Mårten Lindahl
The TMOUT register is always set with a full value for every transfer, which (with a 200MHz clock) will give a full DRTO of ~84 milliseconds. This is normally good enough to complete the request, but setting a full value makes it impossible to test shorter timeouts, when for example testing data read times on different SD cards.
Add a function to set any value smaller than the maximum of
0xFFFFFF.Signed-off-by Mårten Lindahl <[email protected]>---
v2:
- Calculate new value before checking boundaries
- Include CLKDIV register to get proper valuev3:
- Use 'if-else' instead of 'goto'
- Don't touch response field when maximize data fieldv4:
- Prevent 32bit divider overflow by splitting the operation
- Changed %06x to %#08x as suggested by Doug
- Rephrased commit msg as suggested by Dougdrivers/mmc/host/dw_mmc.c | 28 +++++++++++++++++++++++++++- 1 file changed, 27 insertions(+), 1 deletion(-)drivers/mmc/host/dw_mmc.c +0
-0@@ -1283,6 +1283,32 @@ static void dw_mci_setup_bus(struct dw_mci_slot *slot, bool force_clkinit)mci_writel (host,CTYPE , (slot->ctype << slot->id)); }Quoted 11 lines
drivers/mmc/host/dw_mmc.c static void dw_mci_setup_bus(struct dw_mci_slot *slot, bool force_clkinit) · line 1289
Quoted 4 lines
drivers/mmc/host/dw_mmc.c +4
-0+static void dw_mci_set_data_timeout (struct dw_mci *host, +unsigned int timeout_ns) +{ +unsigned int clk_div, tmp, tmout;didn't notice before, but nit that I usually make it a policy that things that represent cpu registers are the "sized" types. Thus I'd rather see these locals as u32 even though the parameter (which represents a logical value and not a CPU register) stays as "unsigned int").
Thanks, will fix.
Quoted 11 lines
drivers/mmc/host/dw_mmc.c static void dw_mci_setup_bus(struct dw_mci_slot *slot, bool force_clkinit) · line 1296
Quoted 7 lines
drivers/mmc/host/dw_mmc.c +6
-0+ clk_div = (mci_readl (host,CLKDIV ) &0xFF ) *2 ; +if (clk_div ==0 ) + clk_div =1 ; + + tmp =DIV_ROUND_UP_ULL ((u64 )timeout_ns * host->bus_hz,NSEC_PER_SEC ); + tmp =DIV_ROUND_UP (tmp, clk_div);I guess in some extreme cases you still have an overflow. Not sure how many people really use "div", but...
Quoted 6 lines
The case I'm thinking of is if the timeout is 80 ms, the
bus_hzis 200 MHz, andclk_divis 20 (register contains 10). I think that would mean you're feeding the controller a 4GHz clock which it probably couldn't _really_ handle, so maybe this isn't super realistic. In any case, I think the first statement would be the equivalent of 80 * 200MHz =0x3b9aca000and that blows out the 32-bit "tmp" variable.Quoted 4 lines
I'm sorry but I fail to follow your calculation here. With 80ms timeout and 200MHz
bus_hz, I get:80000000 * 200000000 / 1000000000 =
0xF42400Sorry, it's just my brain not working properly. Yeah, I think you were fine assuming it was 32-bit. It seems terribly unlikely that
bus_hzcould be anywhere approaching 32-bit max. Even if it was, the timeout is documented to be max on the order of 80 ms:Quoted 6 lines
/* data timeout (in ns, max 80ms) */
...and even if that's wrong and it's 800 ms _and_
bus_hzis the absurdly large0xffffffffthen we still don't timeout.Sorry for getting that wrong. :(
No problem. Reviews are for twisting and turning the code.
To twist it even more, there is no real need to use
DIV_ROUND_UP(_ULL)on the clkdiv division right? I mean the round up has already been made, and it shouldn't be needed twice?So,
tmp = DIV_ROUND_UP_(ULL)(tmp, clk_div);
Quoted 7 lines
Quoted 3 lines
could be a
tmp /= clk_div;I think you still need the round up, but I wouldn't swear to it. You've divided by one value, but not the other and each division could separately need rounding.
Ok, thanks. I'll keep the round up then. I change the unsigned long to u64 in v6.
Kind regards
Mårten
Quoted 2 lines
-Doug