Skip to contentSkip to conversation

clk: k210: Fix error calculation on 32bit

PATCH In review Michal Suchanek 3 participants 10 messages Oct 13, 2022 – Oct 16, 2022 Common clk

lore
Share & tools
lore
#0 lore raw

PATCH 1/1 clk: k210: Fix error calculation on 32bit

k210 is 64bit but the driver and tests are also built in sandbox, and that can be built 32bit.

BIT(32) does not work on 32bit, shift before subtraction to fit into 32bit integer with BIT values.

---

 drivers/clk/clk_k210.c | 2 +-
 test/dm/k210_pll.c     | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)
drivers/clk/clk_k210.c +1 -1
index 1961efaa5e..e85f8ae14a 100644
@@ -846,7 +846,7 @@ again:
 
 		error = DIV_ROUND_CLOSEST_ULL(f * inv_ratio, r * od);
 		/* The lower 16 bits are spurious */
-		error = abs((error - BIT(32))) >> 16;
+		error = abs((error >> 16) - BIT(32 - 16));
 
 		if (error < best_error) {
 			best->r = r;
test/dm/k210_pll.c +1 -1
index a0cc84c396..622b1c9bef 100644
@@ -33,7 +33,7 @@ static int dm_test_k210_pll_calc_config(u32 rate, u32 rate_in,
 				error = DIV_ROUND_CLOSEST_ULL(f * inv_ratio,
 							      r * od);
 				/* The lower 16 bits are spurious */
-				error = abs((error - BIT(32))) >> 16;
+				error = abs((error >> 16) - BIT(32 - 16));
 				if (error < best_error) {
 					best->r = r;
 					best->f = f;
Signature · 1 line
2.37.3
#1 lore raw
Quoted 5 lines · Michal Suchanek

k210 is 64bit but the driver and tests are also built in sandbox, and that can be built 32bit.

BIT(32) does not work on 32bit, shift before subtraction to fit into 32bit integer with BIT values.

Also see
https://patchwork.ozlabs.org/project/uboot/patch/[email protected]/

Quoted 37 lines

---

 drivers/clk/clk_k210.c | 2 +-
 test/dm/k210_pll.c     | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)
drivers/clk/clk_k210.c +1 -1
index 1961efaa5e..e85f8ae14a 100644
@@ -846,7 +846,7 @@ again:
 
 		error = DIV_ROUND_CLOSEST_ULL(f * inv_ratio, r * od);
 		/* The lower 16 bits are spurious */
-		error = abs((error - BIT(32))) >> 16;
+		error = abs((error >> 16) - BIT(32 - 16));
 
 		if (error < best_error) {
 			best->r = r;
test/dm/k210_pll.c +1 -1
index a0cc84c396..622b1c9bef 100644
@@ -33,7 +33,7 @@ static int dm_test_k210_pll_calc_config(u32 rate, u32 rate_in,
 				error = DIV_ROUND_CLOSEST_ULL(f * inv_ratio,
 							      r * od);
 				/* The lower 16 bits are spurious */
-				error = abs((error - BIT(32))) >> 16;
+				error = abs((error >> 16) - BIT(32 - 16));
 				if (error < best_error) {
 					best->r = r;
 					best->f = f;
Signature · 1 line
2.37.3
#2 lore raw
Quoted 24 lines · Michal Suchánek
Quoted 5 lines · Michal Suchanek

k210 is 64bit but the driver and tests are also built in sandbox, and that can be built 32bit.

BIT(32) does not work on 32bit, shift before subtraction to fit into 32bit integer with BIT values.

Also see
https://patchwork.ozlabs.org/project/uboot/patch/[email protected]/

Quoted 14 lines

---

  drivers/clk/clk_k210.c | 2 +-
  test/dm/k210_pll.c     | 2 +-
  2 files changed, 2 insertions(+), 2 deletions(-)
drivers/clk/clk_k210.c +0 -0
index 1961efaa5e..e85f8ae14a 100644
@@ -846,7 +846,7 @@ again:
 
Quoted 4 lines

drivers/clk/clk_k210.c again: · line 849

Quoted 4 lines
drivers/clk/clk_k210.c +1 -1
  		error = DIV_ROUND_CLOSEST_ULL(f * inv_ratio, r * od);
  		/* The lower 16 bits are spurious */
-		error = abs((error - BIT(32))) >> 16;
+		error = abs((error >> 16) - BIT(32 - 16));

Your patch changes the results. Replacing BIT() by BIT_ULL() does not change the result:

error = -1 = 0xffffffffffffffff
before
error - BIT(32) = -4294967297 = 0xfffffffeffffffff abs(error - BIT(32)) = 4294967297 = 0x100000001 abs(error - BIT(32)) >> 16 = 65536 = 0x10000 after
error >> 16 = -1 = 0xffffffffffffffff
(error >> 16) - BIT(32 - 16) = -65537 = 0xfffffffffffeffff abs((error >> 16) - BIT(32 - 16)) = 65537 = 0x10001 using BIT_ULL
abs(error - BIT_ULL(32)) >> 16 = 65536 = 0x10000

error = 70000 = 0x11170
before
error - BIT(32) = -4294897296 = 0xffffffff00011170 abs(error - BIT(32)) = 4294897296 = 0xfffeee90 abs(error - BIT(32)) >> 16 = 65534 = 0xfffe
after
error >> 16 = 1 = 0x1
(error >> 16) - BIT(32 - 16) = -65535 = 0xffffffffffff0001 abs((error >> 16) - BIT(32 - 16)) = 65535 = 0xffff using BIT_ULL
abs(error - BIT_ULL(32)) >> 16 = 65534 = 0xfffe

I assume this change of results is unintended.

We also replace abs() by abs64() to get correct results on a 32bit system:

error = -1 = 0xffffffffffffffff
abs(error - BIT_ULL(32)) >> 16 = 0 = 0x0 abs64(error - BIT_ULL(32)) >> 16 = 65536 = 0x10000 error = 70000 = 0x11170
abs(error - BIT_ULL(32)) >> 16 = 1 = 0x1 abs64(error - BIT_ULL(32)) >> 16 = 65534 = 0xfffe

Best regards

Heinrich

Quoted 19 lines
Quoted 19 lines
drivers/clk/clk_k210.c +0 -0
  		if (error < best_error) {
  			best->r = r;
test/dm/k210_pll.c +1 -1
index a0cc84c396..622b1c9bef 100644
@@ -33,7 +33,7 @@ static int dm_test_k210_pll_calc_config(u32 rate, u32 rate_in,
  				error = DIV_ROUND_CLOSEST_ULL(f * inv_ratio,
  							      r * od);
  				/* The lower 16 bits are spurious */
-				error = abs((error - BIT(32))) >> 16;
+				error = abs((error >> 16) - BIT(32 - 16));
  				if (error < best_error) {
  					best->r = r;
  					best->f = f;
Signature · 1 line
2.37.3
#3 lore raw
Quoted 83 lines · Heinrich Schuchardt
Quoted 18 lines · Michal Suchánek
Quoted 5 lines · Michal Suchanek

k210 is 64bit but the driver and tests are also built in sandbox, and that can be built 32bit.

BIT(32) does not work on 32bit, shift before subtraction to fit into 32bit integer with BIT values.

Also see
https://patchwork.ozlabs.org/project/uboot/patch/[email protected]/

Quoted 8 lines

---

  drivers/clk/clk_k210.c | 2 +-
  test/dm/k210_pll.c     | 2 +-

  2 files changed, 2 insertions(+), 2 deletions(-)
Quoted 9 lines

drivers/clk/clk_k210.c again: · line 848

Quoted 9 lines
drivers/clk/clk_k210.c +1 -1
index 1961efaa5e..e85f8ae14a 100644
@@ -846,7 +846,7 @@ again:
           error = DIV_ROUND_CLOSEST_ULL(f * inv_ratio, r * od);
           /* The lower 16 bits are spurious */
-        error = abs((error - BIT(32))) >> 16;
+        error = abs((error >> 16) - BIT(32 - 16));

Your patch changes the results. Replacing BIT() by BIT_ULL() does not change the result:

error = -1 = 0xffffffffffffffff
before
error - BIT(32) = -4294967297 = 0xfffffffeffffffff abs(error - BIT(32)) = 4294967297 = 0x100000001 abs(error - BIT(32)) >> 16 = 65536 = 0x10000 after
error >> 16 = -1 = 0xffffffffffffffff
(error >> 16) - BIT(32 - 16) = -65537 = 0xfffffffffffeffff abs((error >> 16) - BIT(32 - 16)) = 65537 = 0x10001 using BIT_ULL
abs(error - BIT_ULL(32)) >> 16 = 65536 = 0x10000

error = 70000 = 0x11170
before
error - BIT(32) = -4294897296 = 0xffffffff00011170 abs(error - BIT(32)) = 4294897296 = 0xfffeee90 abs(error - BIT(32)) >> 16 = 65534 = 0xfffe
after
error >> 16 = 1 = 0x1
(error >> 16) - BIT(32 - 16) = -65535 = 0xffffffffffff0001 abs((error >> 16) - BIT(32 - 16)) = 65535 = 0xffff using BIT_ULL
abs(error - BIT_ULL(32)) >> 16 = 65534 = 0xfffe

I assume this change of results is unintended.

We also replace abs() by abs64() to get correct results on a 32bit system:

error = -1 = 0xffffffffffffffff
abs(error - BIT_ULL(32)) >> 16 = 0 = 0x0 abs64(error - BIT_ULL(32)) >> 16 = 65536 = 0x10000 error = 70000 = 0x11170
abs(error - BIT_ULL(32)) >> 16 = 1 = 0x1 abs64(error - BIT_ULL(32)) >> 16 = 65534 = 0xfffe

Best regards

Heinrich

Quoted 10 lines
Quoted 10 lines
drivers/clk/clk_k210.c +0 -0
           if (error < best_error) {
               best->r = r;
test/dm/k210_pll.c +0 -0
index a0cc84c396..622b1c9bef 100644
@@ -33,7 +33,7 @@ static int dm_test_k210_pll_calc_config(u32 rate, u32 rate_in,
                   error = DIV_ROUND_CLOSEST_ULL(f * inv_ratio,
                                     r * od);
                   /* The lower 16 bits are spurious */
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
test/dm/k210_pll.c +1 -1
-                error = abs((error - BIT(32))) >> 16;
+                error = abs((error >> 16) - BIT(32 - 16));
                   if (error < best_error) {
                       best->r = r;
                       best->f = f;
Signature · 1 line
2.37.3

IMO the driver should just be changed to depend on 64-bit. The k210 is 64-bit, and I didn't write anything with 32-bit in mind.

--Sean

#4 lore raw
Quoted 88 lines · Sean Anderson
Quoted 87 lines · Heinrich Schuchardt
Quoted 18 lines · Michal Suchánek
Quoted 5 lines · Michal Suchanek

k210 is 64bit but the driver and tests are also built in sandbox, and that can be built 32bit.

BIT(32) does not work on 32bit, shift before subtraction to fit into 32bit integer with BIT values.

Also see
https://patchwork.ozlabs.org/project/uboot/patch/[email protected]/

Quoted 8 lines

---

  drivers/clk/clk_k210.c | 2 +-
  test/dm/k210_pll.c     | 2 +-

  2 files changed, 2 insertions(+), 2 deletions(-)
Quoted 9 lines

drivers/clk/clk_k210.c again: · line 848

Quoted 9 lines
drivers/clk/clk_k210.c +1 -1
index 1961efaa5e..e85f8ae14a 100644
@@ -846,7 +846,7 @@ again:
           error = DIV_ROUND_CLOSEST_ULL(f * inv_ratio, r * od);
           /* The lower 16 bits are spurious */
-        error = abs((error - BIT(32))) >> 16;
+        error = abs((error >> 16) - BIT(32 - 16));

Your patch changes the results. Replacing BIT() by BIT_ULL() does not change the result:

error = -1 = 0xffffffffffffffff
before
error - BIT(32) = -4294967297 = 0xfffffffeffffffff abs(error - BIT(32)) = 4294967297 = 0x100000001 abs(error - BIT(32)) >> 16 = 65536 = 0x10000 after
error >> 16 = -1 = 0xffffffffffffffff
(error >> 16) - BIT(32 - 16) = -65537 = 0xfffffffffffeffff abs((error >> 16) - BIT(32 - 16)) = 65537 = 0x10001 using BIT_ULL
abs(error - BIT_ULL(32)) >> 16 = 65536 = 0x10000

error = 70000 = 0x11170
before
error - BIT(32) = -4294897296 = 0xffffffff00011170 abs(error - BIT(32)) = 4294897296 = 0xfffeee90 abs(error - BIT(32)) >> 16 = 65534 = 0xfffe
after
error >> 16 = 1 = 0x1
(error >> 16) - BIT(32 - 16) = -65535 = 0xffffffffffff0001 abs((error >> 16) - BIT(32 - 16)) = 65535 = 0xffff using BIT_ULL
abs(error - BIT_ULL(32)) >> 16 = 65534 = 0xfffe

I assume this change of results is unintended.

We also replace abs() by abs64() to get correct results on a 32bit system:

error = -1 = 0xffffffffffffffff
abs(error - BIT_ULL(32)) >> 16 = 0 = 0x0 abs64(error - BIT_ULL(32)) >> 16 = 65536 = 0x10000 error = 70000 = 0x11170
abs(error - BIT_ULL(32)) >> 16 = 1 = 0x1 abs64(error - BIT_ULL(32)) >> 16 = 65534 = 0xfffe

Best regards

Heinrich

Quoted 14 lines
Quoted 14 lines
drivers/clk/clk_k210.c +0 -0
           if (error < best_error) {
               best->r = r;
test/dm/k210_pll.c +1 -1
index a0cc84c396..622b1c9bef 100644
@@ -33,7 +33,7 @@ static int dm_test_k210_pll_calc_config(u32 rate, 
 u32 rate_in,
                   error = DIV_ROUND_CLOSEST_ULL(f * inv_ratio,
                                     r * od);
                   /* The lower 16 bits are spurious */
-                error = abs((error - BIT(32))) >> 16;
+                error = abs((error >> 16) - BIT(32 - 16));
                   if (error < best_error) {
Quoted 8 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
test/dm/k210_pll.c +0 -0
                       best->r = r;

                      best->f = f;

Signature · 1 line
2.37.3

IMO the driver should just be changed to depend on 64-bit. The k210 is 64-bit, and I didn't write anything with 32-bit in mind.

Michal, Simon, and I are striving to get the sandbox working on ilp32 systems.

Do you suggest to remove the driver from sandbox_defconfig?

This would imply that the unit test is not executed on Gitlab CI. You will still be able to execute it on the actual hardware.

Best regards

Heinrich

#5 lore raw
Quoted 99 lines · Heinrich Schuchardt
Quoted 87 lines · Sean Anderson
Quoted 86 lines · Heinrich Schuchardt
Quoted 18 lines · Michal Suchánek
Quoted 5 lines · Michal Suchanek

k210 is 64bit but the driver and tests are also built in sandbox, and that can be built 32bit.

BIT(32) does not work on 32bit, shift before subtraction to fit into 32bit integer with BIT values.

Also see
https://patchwork.ozlabs.org/project/uboot/patch/[email protected]/

Quoted 8 lines

---

  drivers/clk/clk_k210.c | 2 +-
  test/dm/k210_pll.c     | 2 +-

  2 files changed, 2 insertions(+), 2 deletions(-)
Quoted 9 lines

drivers/clk/clk_k210.c again: · line 848

Quoted 9 lines
drivers/clk/clk_k210.c +1 -1
index 1961efaa5e..e85f8ae14a 100644
@@ -846,7 +846,7 @@ again:
           error = DIV_ROUND_CLOSEST_ULL(f * inv_ratio, r * od);
           /* The lower 16 bits are spurious */
-        error = abs((error - BIT(32))) >> 16;
+        error = abs((error >> 16) - BIT(32 - 16));

Your patch changes the results. Replacing BIT() by BIT_ULL() does not change the result:

error = -1 = 0xffffffffffffffff
before
error - BIT(32) = -4294967297 = 0xfffffffeffffffff abs(error - BIT(32)) = 4294967297 = 0x100000001 abs(error - BIT(32)) >> 16 = 65536 = 0x10000 after
error >> 16 = -1 = 0xffffffffffffffff
(error >> 16) - BIT(32 - 16) = -65537 = 0xfffffffffffeffff abs((error >> 16) - BIT(32 - 16)) = 65537 = 0x10001 using BIT_ULL
abs(error - BIT_ULL(32)) >> 16 = 65536 = 0x10000

error = 70000 = 0x11170
before
error - BIT(32) = -4294897296 = 0xffffffff00011170 abs(error - BIT(32)) = 4294897296 = 0xfffeee90 abs(error - BIT(32)) >> 16 = 65534 = 0xfffe
after
error >> 16 = 1 = 0x1
(error >> 16) - BIT(32 - 16) = -65535 = 0xffffffffffff0001 abs((error >> 16) - BIT(32 - 16)) = 65535 = 0xffff using BIT_ULL
abs(error - BIT_ULL(32)) >> 16 = 65534 = 0xfffe

I assume this change of results is unintended.

We also replace abs() by abs64() to get correct results on a 32bit system:

error = -1 = 0xffffffffffffffff
abs(error - BIT_ULL(32)) >> 16 = 0 = 0x0 abs64(error - BIT_ULL(32)) >> 16 = 65536 = 0x10000 error = 70000 = 0x11170
abs(error - BIT_ULL(32)) >> 16 = 1 = 0x1 abs64(error - BIT_ULL(32)) >> 16 = 65534 = 0xfffe

Best regards

Heinrich

Quoted 13 lines
Quoted 13 lines
drivers/clk/clk_k210.c +0 -0
           if (error < best_error) {
               best->r = r;
test/dm/k210_pll.c +1 -1
index a0cc84c396..622b1c9bef 100644
@@ -33,7 +33,7 @@ static int dm_test_k210_pll_calc_config(u32 rate, u32 rate_in,
                   error = DIV_ROUND_CLOSEST_ULL(f * inv_ratio,
                                     r * od);
                   /* The lower 16 bits are spurious */
-                error = abs((error - BIT(32))) >> 16;
+                error = abs((error >> 16) - BIT(32 - 16));
                   if (error < best_error) {
Quoted 8 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
test/dm/k210_pll.c +0 -0
                       best->r = r;
                       best->f = f;
Signature · 1 line
2.37.3

IMO the driver should just be changed to depend on 64-bit. The k210 is 64-bit, and I didn't write anything with 32-bit in mind.

Quoted 5 lines

Michal, Simon, and I are striving to get the sandbox working on ilp32 systems.

Do you suggest to remove  the driver from sandbox_defconfig?

This would imply that the unit test is not executed on Gitlab CI. You will still be able to execute it on the actual hardware.

It's still enabled for sandbox64, so it should still be executed there.

--Sean

#6 lore raw
Quoted 101 lines · Sean Anderson
Quoted 100 lines · Heinrich Schuchardt
Quoted 96 lines · Sean Anderson
Quoted 84 lines · Heinrich Schuchardt
Quoted 18 lines · Michal Suchánek
Quoted 5 lines · Michal Suchanek

k210 is 64bit but the driver and tests are also built in sandbox, and that can be built 32bit.

BIT(32) does not work on 32bit, shift before subtraction to fit into 32bit integer with BIT values.

Also see
https://patchwork.ozlabs.org/project/uboot/patch/[email protected]/

Quoted 8 lines

---

  drivers/clk/clk_k210.c | 2 +-
  test/dm/k210_pll.c     | 2 +-

  2 files changed, 2 insertions(+), 2 deletions(-)
Quoted 9 lines

drivers/clk/clk_k210.c again: · line 848

Quoted 9 lines
drivers/clk/clk_k210.c +1 -1
index 1961efaa5e..e85f8ae14a 100644
@@ -846,7 +846,7 @@ again:
           error = DIV_ROUND_CLOSEST_ULL(f * inv_ratio, r * od);
           /* The lower 16 bits are spurious */
-        error = abs((error - BIT(32))) >> 16;
+        error = abs((error >> 16) - BIT(32 - 16));

Your patch changes the results. Replacing BIT() by BIT_ULL() does not change the result:

error = -1 = 0xffffffffffffffff
before
error - BIT(32) = -4294967297 = 0xfffffffeffffffff abs(error - BIT(32)) = 4294967297 = 0x100000001 abs(error - BIT(32)) >> 16 = 65536 = 0x10000 after
error >> 16 = -1 = 0xffffffffffffffff
(error >> 16) - BIT(32 - 16) = -65537 = 0xfffffffffffeffff abs((error >> 16) - BIT(32 - 16)) = 65537 = 0x10001 using BIT_ULL
abs(error - BIT_ULL(32)) >> 16 = 65536 = 0x10000

error = 70000 = 0x11170
before
error - BIT(32) = -4294897296 = 0xffffffff00011170 abs(error - BIT(32)) = 4294897296 = 0xfffeee90 abs(error - BIT(32)) >> 16 = 65534 = 0xfffe
after
error >> 16 = 1 = 0x1
(error >> 16) - BIT(32 - 16) = -65535 = 0xffffffffffff0001 abs((error >> 16) - BIT(32 - 16)) = 65535 = 0xffff using BIT_ULL
abs(error - BIT_ULL(32)) >> 16 = 65534 = 0xfffe

I assume this change of results is unintended.

We also replace abs() by abs64() to get correct results on a 32bit system:

error = -1 = 0xffffffffffffffff
abs(error - BIT_ULL(32)) >> 16 = 0 = 0x0 abs64(error - BIT_ULL(32)) >> 16 = 65536 = 0x10000 error = 70000 = 0x11170
abs(error - BIT_ULL(32)) >> 16 = 1 = 0x1 abs64(error - BIT_ULL(32)) >> 16 = 65534 = 0xfffe

Best regards

Heinrich

Quoted 11 lines
Quoted 11 lines
drivers/clk/clk_k210.c +0 -0
           if (error < best_error) {
               best->r = r;
test/dm/k210_pll.c +0 -0
index a0cc84c396..622b1c9bef 100644
@@ -33,7 +33,7 @@ static int dm_test_k210_pll_calc_config(u32 
 rate, u32 rate_in,
                   error = DIV_ROUND_CLOSEST_ULL(f * inv_ratio,
                                     r * od);
                   /* The lower 16 bits are spurious */
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
test/dm/k210_pll.c +1 -1
-                error = abs((error - BIT(32))) >> 16;
+                error = abs((error >> 16) - BIT(32 - 16));
                   if (error < best_error) {
                       best->r = r;

                      best->f = f;

Signature · 1 line
2.37.3

IMO the driver should just be changed to depend on 64-bit. The k210 is 64-bit, and I didn't write anything with 32-bit in mind.

Quoted 7 lines
Quoted 5 lines

Michal, Simon, and I are striving to get the sandbox working on ilp32 systems.

Do you suggest to remove  the driver from sandbox_defconfig?

This would imply that the unit test is not executed on Gitlab CI. You will still be able to execute it on the actual hardware.

It's still enabled for sandbox64, so it should still be executed there.

No, the sandbox64 is also to be compiled on ilp32. It models physical address extension (PAE).

Best regards

Heinrich

#7 lore raw
Quoted 105 lines · Heinrich Schuchardt
Quoted 102 lines · Sean Anderson
Quoted 101 lines · Heinrich Schuchardt
Quoted 87 lines · Sean Anderson
Quoted 86 lines · Heinrich Schuchardt
Quoted 18 lines · Michal Suchánek
Quoted 5 lines · Michal Suchanek

k210 is 64bit but the driver and tests are also built in sandbox, and that can be built 32bit.

BIT(32) does not work on 32bit, shift before subtraction to fit into 32bit integer with BIT values.

Also see
https://patchwork.ozlabs.org/project/uboot/patch/[email protected]/

Quoted 8 lines

---

  drivers/clk/clk_k210.c | 2 +-
  test/dm/k210_pll.c     | 2 +-

  2 files changed, 2 insertions(+), 2 deletions(-)
Quoted 9 lines

drivers/clk/clk_k210.c again: · line 848

Quoted 9 lines
drivers/clk/clk_k210.c +1 -1
index 1961efaa5e..e85f8ae14a 100644
@@ -846,7 +846,7 @@ again:
           error = DIV_ROUND_CLOSEST_ULL(f * inv_ratio, r * od);
           /* The lower 16 bits are spurious */
-        error = abs((error - BIT(32))) >> 16;
+        error = abs((error >> 16) - BIT(32 - 16));

Your patch changes the results. Replacing BIT() by BIT_ULL() does not change the result:

error = -1 = 0xffffffffffffffff
before
error - BIT(32) = -4294967297 = 0xfffffffeffffffff abs(error - BIT(32)) = 4294967297 = 0x100000001 abs(error - BIT(32)) >> 16 = 65536 = 0x10000 after
error >> 16 = -1 = 0xffffffffffffffff
(error >> 16) - BIT(32 - 16) = -65537 = 0xfffffffffffeffff abs((error >> 16) - BIT(32 - 16)) = 65537 = 0x10001 using BIT_ULL
abs(error - BIT_ULL(32)) >> 16 = 65536 = 0x10000

error = 70000 = 0x11170
before
error - BIT(32) = -4294897296 = 0xffffffff00011170 abs(error - BIT(32)) = 4294897296 = 0xfffeee90 abs(error - BIT(32)) >> 16 = 65534 = 0xfffe
after
error >> 16 = 1 = 0x1
(error >> 16) - BIT(32 - 16) = -65535 = 0xffffffffffff0001 abs((error >> 16) - BIT(32 - 16)) = 65535 = 0xffff using BIT_ULL
abs(error - BIT_ULL(32)) >> 16 = 65534 = 0xfffe

I assume this change of results is unintended.

We also replace abs() by abs64() to get correct results on a 32bit system:

error = -1 = 0xffffffffffffffff
abs(error - BIT_ULL(32)) >> 16 = 0 = 0x0 abs64(error - BIT_ULL(32)) >> 16 = 65536 = 0x10000 error = 70000 = 0x11170
abs(error - BIT_ULL(32)) >> 16 = 1 = 0x1 abs64(error - BIT_ULL(32)) >> 16 = 65534 = 0xfffe

Best regards

Heinrich

Quoted 13 lines
Quoted 13 lines
drivers/clk/clk_k210.c +0 -0
           if (error < best_error) {
               best->r = r;
test/dm/k210_pll.c +1 -1
index a0cc84c396..622b1c9bef 100644
@@ -33,7 +33,7 @@ static int dm_test_k210_pll_calc_config(u32 rate, u32 rate_in,
                   error = DIV_ROUND_CLOSEST_ULL(f * inv_ratio,
                                     r * od);
                   /* The lower 16 bits are spurious */
-                error = abs((error - BIT(32))) >> 16;
+                error = abs((error >> 16) - BIT(32 - 16));
                   if (error < best_error) {
Quoted 8 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
test/dm/k210_pll.c +0 -0
                       best->r = r;
                       best->f = f;
Signature · 1 line
2.37.3

IMO the driver should just be changed to depend on 64-bit. The k210 is 64-bit, and I didn't write anything with 32-bit in mind.

Michal, Simon, and I are striving to get the sandbox working on ilp32 systems.

Quoted 7 lines
Quoted 5 lines
Quoted 3 lines

Do you suggest to remove  the driver from sandbox_defconfig?

This would imply that the unit test is not executed on Gitlab CI. You will still be able to execute it on the actual hardware.

It's still enabled for sandbox64, so it should still be executed there.

No, the sandbox64 is also to be compiled on ilp32. It models physical address extension (PAE).

Do we have a config for word size? PHYS_64BIT seems to be for the address size.

--Sean

#8 lore raw
Quoted 109 lines · Sean Anderson
Quoted 108 lines · Heinrich Schuchardt
Quoted 105 lines · Sean Anderson
Quoted 104 lines · Heinrich Schuchardt
Quoted 88 lines · Sean Anderson
Quoted 87 lines · Heinrich Schuchardt
Quoted 18 lines · Michal Suchánek
Quoted 5 lines · Michal Suchanek

k210 is 64bit but the driver and tests are also built in sandbox, and that can be built 32bit.

BIT(32) does not work on 32bit, shift before subtraction to fit into 32bit integer with BIT values.

Also see
https://patchwork.ozlabs.org/project/uboot/patch/[email protected]/

Quoted 8 lines

---

  drivers/clk/clk_k210.c | 2 +-
  test/dm/k210_pll.c     | 2 +-

  2 files changed, 2 insertions(+), 2 deletions(-)
Quoted 9 lines

drivers/clk/clk_k210.c again: · line 848

Quoted 9 lines
drivers/clk/clk_k210.c +1 -1
index 1961efaa5e..e85f8ae14a 100644
@@ -846,7 +846,7 @@ again:
           error = DIV_ROUND_CLOSEST_ULL(f * inv_ratio, r * od);
           /* The lower 16 bits are spurious */
-        error = abs((error - BIT(32))) >> 16;
+        error = abs((error >> 16) - BIT(32 - 16));

Your patch changes the results. Replacing BIT() by BIT_ULL() does not change the result:

error = -1 = 0xffffffffffffffff
before
error - BIT(32) = -4294967297 = 0xfffffffeffffffff abs(error - BIT(32)) = 4294967297 = 0x100000001 abs(error - BIT(32)) >> 16 = 65536 = 0x10000 after
error >> 16 = -1 = 0xffffffffffffffff
(error >> 16) - BIT(32 - 16) = -65537 = 0xfffffffffffeffff abs((error >> 16) - BIT(32 - 16)) = 65537 = 0x10001 using BIT_ULL
abs(error - BIT_ULL(32)) >> 16 = 65536 = 0x10000

error = 70000 = 0x11170
before
error - BIT(32) = -4294897296 = 0xffffffff00011170 abs(error - BIT(32)) = 4294897296 = 0xfffeee90 abs(error - BIT(32)) >> 16 = 65534 = 0xfffe
after
error >> 16 = 1 = 0x1
(error >> 16) - BIT(32 - 16) = -65535 = 0xffffffffffff0001 abs((error >> 16) - BIT(32 - 16)) = 65535 = 0xffff using BIT_ULL
abs(error - BIT_ULL(32)) >> 16 = 65534 = 0xfffe

I assume this change of results is unintended.

We also replace abs() by abs64() to get correct results on a 32bit system:

error = -1 = 0xffffffffffffffff
abs(error - BIT_ULL(32)) >> 16 = 0 = 0x0 abs64(error - BIT_ULL(32)) >> 16 = 65536 = 0x10000 error = 70000 = 0x11170
abs(error - BIT_ULL(32)) >> 16 = 1 = 0x1 abs64(error - BIT_ULL(32)) >> 16 = 65534 = 0xfffe

Best regards

Heinrich

Quoted 14 lines
Quoted 14 lines
drivers/clk/clk_k210.c +0 -0
           if (error < best_error) {
               best->r = r;
test/dm/k210_pll.c +1 -1
index a0cc84c396..622b1c9bef 100644
@@ -33,7 +33,7 @@ static int dm_test_k210_pll_calc_config(u32 
 rate, u32 rate_in,
                   error = DIV_ROUND_CLOSEST_ULL(f * inv_ratio,
                                     r * od);
                   /* The lower 16 bits are spurious */
-                error = abs((error - BIT(32))) >> 16;
+                error = abs((error >> 16) - BIT(32 - 16));
                   if (error < best_error) {
Quoted 8 lines
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
test/dm/k210_pll.c +0 -0
                       best->r = r;

                      best->f = f;

Signature · 1 line
2.37.3

IMO the driver should just be changed to depend on 64-bit. The k210 is 64-bit, and I didn't write anything with 32-bit in mind.

Michal, Simon, and I are striving to get the sandbox working on ilp32 systems.

Do you suggest to remove  the driver from sandbox_defconfig?

Quoted 7 lines
Quoted 5 lines
Quoted 3 lines
Quoted 1 line

This would imply that the unit test is not executed on Gitlab CI. You will still be able to execute it on the actual hardware.

It's still enabled for sandbox64, so it should still be executed there.

No, the sandbox64 is also to be compiled on ilp32. It models physical address extension (PAE).

Do we have a config for word size? PHYS_64BIT seems to be for the address size.

phys_addr_t is what is used to address physical memory which may be 64bit on a 32bit PAE system (CONFIG_PHYS_64BIT=y).

Compiling on armv7 yields 32bit pointers.

There are two alternative patches in review removing HOST_32BIT and HOST_64BIT:

https://patchwork.ozlabs.org/project/uboot/patch/[email protected]/

https://patchwork.ozlabs.org/project/uboot/patch/[email protected]/

Best regards

Heinrich

#9 lore raw

Hello,

Quoted 49 lines · Heinrich Schuchardt
Quoted 35 lines · Sean Anderson
Quoted 34 lines · Heinrich Schuchardt
Quoted 31 lines · Sean Anderson
Quoted 29 lines · Heinrich Schuchardt
Quoted 9 lines · Sean Anderson
Quoted 8 lines · Heinrich Schuchardt
Quoted 5 lines · Michal Suchánek
Quoted 4 lines · Michal Suchanek

k210 is 64bit but the driver and tests are
also built in sandbox, and
that can be built 32bit.

Quoted 8 lines
Quoted 3 lines
Quoted 3 lines
Quoted 3 lines

BIT(32) does not work on 32bit, shift before
subtraction to fit into
32bit integer with BIT values.

IMO the driver should just be changed to depend on 64-bit. The k210 is 64-bit,
and I didn't write anything with 32-bit in mind.

Michal, Simon, and I are striving to get the sandbox working on ilp32 systems.

Do you suggest to remove  the driver from sandbox_defconfig?

This would imply that the unit test is not executed on Gitlab CI. You will still be able to execute it on the actual hardware.

Quoted 7 lines
Quoted 4 lines
Quoted 1 line

It's still enabled for sandbox64, so it should still be executed there.

No, the sandbox64 is also to be compiled on ilp32. It models physical address extension (PAE).

Do we have a config for word size? PHYS_64BIT seems to be for the address size.

phys_addr_t is what is used to address physical memory which may be 64bit on a 32bit PAE system (CONFIG_PHYS_64BIT=y).

Quoted 8 lines

Compiling on armv7 yields 32bit pointers.

There are two alternative patches in review removing HOST_32BIT and HOST_64BIT:

https://patchwork.ozlabs.org/project/uboot/patch/[email protected]/

https://patchwork.ozlabs.org/project/uboot/patch/[email protected]/

I don't think that we have a config option that can be used to detect that the build is 64bit. Such option may exit per platform but drivers that can be built for multiple platforms will have hard time detecting it.

I think that Heinrich's suggestion to use BIT_ULL instead of BIT and abs64 instead of abs is non-controversial. It's technically more correct way to write the expression although relevant only for 32bit.

Thanks

Michal