[RFC PATCH 2/3] clk: sunxi-ng: Implement precalculated NKM rate selection

[Frank Oltmanns]

Add a new precalculation method for NKM clock rate selection in the
sunxi-ng clock driver. Introduce ccu_nkm_find_best_precalc which uses a
precalculated table of valid NKM combinations (struct clk_nkm_table and
struct clk_nkm_combo) to find the best rate. This approach provides
faster rate selection by searching a table of valid combinations rather
than calculating for all possible combinations.

The table of NKM combinations needs to be initialized with meaningful
combinations only, i.e. removing redundant combinations that result in
the same rate.

Keep the existing ccu_nkm_find_best function in place and use it as a
fallback if no precalculated table is provided.

Signed-off-by: Frank Oltmanns <frank at oltmanns.dev>
---
 drivers/clk/sunxi-ng/ccu_nkm.c | 84 +++++++++++++++++++++++++++-------
 drivers/clk/sunxi-ng/ccu_nkm.h | 26 +++++++++++
 2 files changed, 94 insertions(+), 16 deletions(-)

diff --git a/drivers/clk/sunxi-ng/ccu_nkm.c b/drivers/clk/sunxi-ng/ccu_nkm.c
index 94d2a83992b2..9652f6df17bd 100644
--- a/drivers/clk/sunxi-ng/ccu_nkm.c
+++ b/drivers/clk/sunxi-ng/ccu_nkm.c
@@ -54,6 +54,49 @@ static unsigned long ccu_nkm_find_best(unsigned long parent, unsigned long rate,
 	return best_rate;
 }
 
+static unsigned long ccu_nkm_find_best_precalc(unsigned long parent,
+					       unsigned long rate,
+					       struct _ccu_nkm *nkm,
+					       struct clk_nkm_table *table)
+{
+	unsigned long best_rate = 0, best_diff = ULONG_MAX;
+	unsigned long best_n = 0, best_k = 0, best_m = 0;
+	int start = 0, end = table->num - 1, mid;
+
+	while (start <= end) {
+		unsigned long tmp_rate;
+		unsigned long tmp_diff;
+
+		mid = (start + end) / 2;
+
+		tmp_rate = parent * table->combos[mid].n * table->combos[mid].k /
+			   table->combos[mid].m;
+
+		tmp_diff = abs(rate - tmp_rate);
+
+		if (tmp_diff < best_diff) {
+			best_rate = tmp_rate;
+			best_diff = tmp_diff;
+			best_n = table->combos[mid].n;
+			best_k = table->combos[mid].k;
+			best_m = table->combos[mid].m;
+			if (best_diff == 0)
+				goto out;
+		}
+		if (rate < tmp_rate)
+			end = mid - 1;
+		else
+			start = mid + 1;
+	}
+
+out:
+	nkm->n = best_n;
+	nkm->k = best_k;
+	nkm->m = best_m;
+
+	return best_rate;
+}
+
 static void ccu_nkm_disable(struct clk_hw *hw)
 {
 	struct ccu_nkm *nkm = hw_to_ccu_nkm(hw);
@@ -119,17 +162,22 @@ static unsigned long ccu_nkm_round_rate(struct ccu_mux_internal *mux,
 	struct ccu_nkm *nkm = data;
 	struct _ccu_nkm _nkm;
 
-	_nkm.min_n = nkm->n.min ?: 1;
-	_nkm.max_n = nkm->n.max ?: 1 << nkm->n.width;
-	_nkm.min_k = nkm->k.min ?: 1;
-	_nkm.max_k = nkm->k.max ?: 1 << nkm->k.width;
-	_nkm.min_m = 1;
-	_nkm.max_m = nkm->m.max ?: 1 << nkm->m.width;
-
 	if (nkm->common.features & CCU_FEATURE_FIXED_POSTDIV)
 		rate *= nkm->fixed_post_div;
 
-	rate = ccu_nkm_find_best(*parent_rate, rate, &_nkm);
+	if (nkm->table.num)
+		rate = ccu_nkm_find_best_precalc(*parent_rate, rate, &_nkm,
+						 &nkm->table);
+	else {
+		_nkm.min_n = nkm->n.min ?: 1;
+		_nkm.max_n = nkm->n.max ?: 1 << nkm->n.width;
+		_nkm.min_k = nkm->k.min ?: 1;
+		_nkm.max_k = nkm->k.max ?: 1 << nkm->k.width;
+		_nkm.min_m = 1;
+		_nkm.max_m = nkm->m.max ?: 1 << nkm->m.width;
+
+		rate = ccu_nkm_find_best(*parent_rate, rate, &_nkm);
+	}
 
 	if (nkm->common.features & CCU_FEATURE_FIXED_POSTDIV)
 		rate /= nkm->fixed_post_div;
@@ -157,14 +205,18 @@ static int ccu_nkm_set_rate(struct clk_hw *hw, unsigned long rate,
 	if (nkm->common.features & CCU_FEATURE_FIXED_POSTDIV)
 		rate *= nkm->fixed_post_div;
 
-	_nkm.min_n = nkm->n.min ?: 1;
-	_nkm.max_n = nkm->n.max ?: 1 << nkm->n.width;
-	_nkm.min_k = nkm->k.min ?: 1;
-	_nkm.max_k = nkm->k.max ?: 1 << nkm->k.width;
-	_nkm.min_m = 1;
-	_nkm.max_m = nkm->m.max ?: 1 << nkm->m.width;
-
-	ccu_nkm_find_best(parent_rate, rate, &_nkm);
+	if (nkm->table.num)
+		rate = ccu_nkm_find_best_precalc(*parent_rate, rate, &_nkm,
+						 &nkm->table);
+	else {
+		_nkm.min_n = nkm->n.min ?: 1;
+		_nkm.max_n = nkm->n.max ?: 1 << nkm->n.width;
+		_nkm.min_k = nkm->k.min ?: 1;
+		_nkm.max_k = nkm->k.max ?: 1 << nkm->k.width;
+		_nkm.min_m = 1;
+		_nkm.max_m = nkm->m.max ?: 1 << nkm->m.width;
+		ccu_nkm_find_best(parent_rate, rate, &_nkm);
+	}
 
 	spin_lock_irqsave(nkm->common.lock, flags);
 
diff --git a/drivers/clk/sunxi-ng/ccu_nkm.h b/drivers/clk/sunxi-ng/ccu_nkm.h
index 6601defb3f38..fa5551724921 100644
--- a/drivers/clk/sunxi-ng/ccu_nkm.h
+++ b/drivers/clk/sunxi-ng/ccu_nkm.h
@@ -12,6 +12,30 @@
 #include "ccu_div.h"
 #include "ccu_mult.h"
 
+struct clk_nkm_combo {
+	u8	n;
+	u8	k;
+	u8	m;
+};
+
+/**
+ * struct clk_nkm_table - Table of all meaningful combinations for n, k, and m
+ *
+ * @num: Number of entries in the table
+ * @combos: Array of combos (of size num) that are supported by this clock.
+ *
+ * This table shall contain all meaningful combinations of n, k, and m. That
+ * means that combinations that result in the same clock rate shall only be
+ * listed once. For example, if both
+ * { .n = 1, .k = 2, .m = 2} and  { .n = 2, .k = 2, .m = 4}
+ * are valid values for n, k, and m, only one of them would be allowed because
+ * both result in a factor of 1.0.
+ */
+struct clk_nkm_table {
+	size_t			num;
+	struct clk_nkm_combo	*combos;
+};
+
 /*
  * struct ccu_nkm - Definition of an N-K-M clock
  *
@@ -29,6 +53,8 @@ struct ccu_nkm {
 	unsigned int		fixed_post_div;
 
 	struct ccu_common	common;
+
+	struct clk_nkm_table	table;
 };
 
 #define SUNXI_CCU_NKM_WITH_MUX_GATE_LOCK(_struct, _name, _parents, _reg, \
-- 
2.40.1