@@ -97,6 +97,8 @@ struct rk3x_i2c {
/* Hardware resources */
void __iomem *regs;
struct clk *clk;
+ struct notifier_block clk_rate_nb;
+ unsigned long clk_freq;
/* Settings */
unsigned int scl_frequency;
@@ -428,18 +430,123 @@ out:
return IRQ_HANDLED;
}
-static void rk3x_i2c_set_scl_rate(struct rk3x_i2c *i2c, unsigned long scl_rate)
+/**
+ * Calculate divider value for desired SCL frequency
+ *
+ * @clk_rate: I2C input clock rate
+ * @scl_rate: Desired SCL rate
+ * @div: Divider output
+ *
+ * Return: 0 on success, -EINVAL on unreachable SCL rate. In that case
+ * a best-effort divider value is returned in div.
+ **/
+static int rk3x_i2c_calc_div(unsigned long clk_rate, unsigned long scl_rate,
+ unsigned int *div)
{
- unsigned long i2c_rate = clk_get_rate(i2c->clk);
- unsigned int div;
+ unsigned long div_tmp;
/* set DIV = DIVH = DIVL
* SCL rate = (clk rate) / (8 * (DIVH + 1 + DIVL + 1))
* = (clk rate) / (16 * (DIV + 1))
*/
- div = DIV_ROUND_UP(i2c_rate, scl_rate * 16) - 1;
+ div_tmp = DIV_ROUND_UP(clk_rate, scl_rate * 16) - 1;
+
+ if (div_tmp > 0xFFFF) {
+ /* The input clock is too fast. Reject this rate change. */
+ *div = 0xFFFF;
+ return -EINVAL;
+ }
+
+ *div = div_tmp;
+
+ return 0;
+}
+
+/**
+ * Setup divider register for desired SCL frequency
+ *
+ * @scl_rate: Desired SCL Rate
+ **/
+static void rk3x_i2c_set_scl_rate(struct rk3x_i2c *i2c, unsigned long scl_rate)
+{
+ unsigned long i2c_rate = clk_get_rate(i2c->clk);
+ unsigned int div;
+ int ret;
+
+ ret = rk3x_i2c_calc_div(i2c_rate, scl_rate, &div);
+
+ WARN_ONCE(ret != 0, "Could not reach desired SCL freq %lu", scl_rate);
+
+ /*
+ * We might be called from rk3x_i2c_probe or from the clk rate change
+ * notifier. In that case, the i2c clk is not running. So enable it
+ * explicitly here during the register write.
+ *
+ * Writing the register with halted clock crashes the system at least on
+ * RK3288.
+ */
+ clk_enable(i2c->clk);
i2c_writel(i2c, (div << 16) | (div & 0xffff), REG_CLKDIV);
+ clk_disable(i2c->clk);
+}
+
+/**
+ * rk3x_i2c_clk_notifier_cb - Clock rate change callback
+ * @nb: Pointer to notifier block
+ * @event: Notification reason
+ * @data: Pointer to notification data object
+ *
+ * The callback checks whether a valid bus frequency can be generated after the
+ * change. If so, the change is acknowledged, otherwise the change is aborted.
+ * New dividers are written to the HW in the pre- or post change notification
+ * depending on the scaling direction.
+ *
+ * Code adapted from i2c-cadence.c.
+ *
+ * Return: NOTIFY_STOP if the rate change should be aborted, NOTIFY_OK
+ * to acknowedge the change, NOTIFY_DONE if the notification is
+ * considered irrelevant.
+ */
+static int rk3x_i2c_clk_notifier_cb(struct notifier_block *nb, unsigned long
+ event, void *data)
+{
+ struct clk_notifier_data *ndata = data;
+ struct rk3x_i2c *i2c = container_of(nb, struct rk3x_i2c, clk_rate_nb);
+
+ switch (event) {
+ case PRE_RATE_CHANGE:
+ {
+ unsigned int div;
+
+ if (rk3x_i2c_calc_div(ndata->new_rate, i2c->scl_frequency,
+ &div) != 0) {
+ return NOTIFY_STOP;
+ }
+
+ i2c->clk_freq = ndata->new_rate;
+
+ /* scale up */
+ if (ndata->new_rate > ndata->old_rate)
+ rk3x_i2c_set_scl_rate(i2c, ndata->new_rate);
+
+ return NOTIFY_OK;
+ }
+ case POST_RATE_CHANGE:
+ i2c->clk_freq = ndata->new_rate;
+
+ /* scale down */
+ if (ndata->new_rate < ndata->old_rate)
+ rk3x_i2c_set_scl_rate(i2c, ndata->new_rate);
+ return NOTIFY_OK;
+ case ABORT_RATE_CHANGE:
+ /* scale up */
+ if (ndata->new_rate > ndata->old_rate)
+ rk3x_i2c_set_scl_rate(i2c, ndata->old_rate);
+ return NOTIFY_OK;
+ default:
+ return NOTIFY_DONE;
+ }
}
/**
@@ -536,9 +643,6 @@ static int rk3x_i2c_xfer(struct i2c_adapter *adap,
clk_enable(i2c->clk);
- /* The clock rate might have changed, so setup the divider again */
- rk3x_i2c_set_scl_rate(i2c, i2c->scl_frequency);
-
i2c->is_last_msg = false;
/*
@@ -724,16 +828,28 @@ static int rk3x_i2c_probe(struct platform_device *pdev)
return ret;
}
+ i2c->clk_rate_nb.notifier_call = rk3x_i2c_clk_notifier_cb;
+ ret = clk_notifier_register(i2c->clk, &i2c->clk_rate_nb);
+ if (ret != 0) {
+ dev_err(&pdev->dev, "Unable to register clock notifier\n");
+ goto err_clk;
+ }
+
+ i2c->clk_freq = clk_get_rate(i2c->clk);
+ rk3x_i2c_set_scl_rate(i2c, i2c->scl_frequency);
+
ret = i2c_add_adapter(&i2c->adap);
if (ret < 0) {
dev_err(&pdev->dev, "Could not register adapter\n");
- goto err_clk;
+ goto err_clk_notifier;
}
dev_info(&pdev->dev, "Initialized RK3xxx I2C bus at %p\n", i2c->regs);
return 0;
+err_clk_notifier:
+ clk_notifier_unregister(i2c->clk, &i2c->clk_rate_nb);
err_clk:
clk_unprepare(i2c->clk);
return ret;
@@ -744,6 +860,8 @@ static int rk3x_i2c_remove(struct platform_device *pdev)
struct rk3x_i2c *i2c = platform_get_drvdata(pdev);
i2c_del_adapter(&i2c->adap);
+
+ clk_notifier_unregister(i2c->clk, &i2c->clk_rate_nb);
clk_unprepare(i2c->clk);
return 0;