Skip to contentSkip to conversation

clk: Add driver for MAX9485

PATCH Superseded Daniel Mack 3 participants 7 messages May 25, 2018 – Jun 2, 2018

Subsystems (2)

v2 of 5 Superseded Latest is v5 →

lore
Share & tools
lore
#0 lore raw

v2 cover clk: Add driver for MAX9485

This is v2 of the driver for Maxim's MAX9485 programmable audio clock generator.

v1 → v2:

* Now served as two patches, one for the DT bits, and one for the actual implementation. The DT bits are put in the 1st patch because the implementation depends on the shared header file.

* Added support for suspend/resume

Daniel Mack (2):
dts: clk: add devicetree bindings for MAX9485
clk: Add driver for MAX9485

 .../devicetree/bindings/clock/maxim,max9485.txt    |  59 +++
 drivers/clk/Kconfig                                |   8 +
 drivers/clk/Makefile                               |   1 +
 drivers/clk/clk-max9485.c                          | 408 +++++++++++++++++++++
 include/dt-bindings/clock/maxim,max9485.h          |  18 +
 5 files changed, 494 insertions(+)
 create mode 100644 Documentation/devicetree/bindings/clock/maxim,max9485.txt
 create mode 100644 drivers/clk/clk-max9485.c
 create mode 100644 include/dt-bindings/clock/maxim,max9485.h
Signature · 1 line
2.14.3
#1 lore raw

PATCH v2 1/2 dts: clk: add devicetree bindings for MAX9485

This patch adds the devicetree bindings for MAX9485, a programmable audio clock generator.

---
 .../devicetree/bindings/clock/maxim,max9485.txt    | 59 ++++++++++++++++++++++
 include/dt-bindings/clock/maxim,max9485.h          | 18 +++++++
 2 files changed, 77 insertions(+)
 create mode 100644 Documentation/devicetree/bindings/clock/maxim,max9485.txt
 create mode 100644 include/dt-bindings/clock/maxim,max9485.h
Documentation/devicetree/bindings/clock/maxim,max9485.txt new file +59 -0
new file mode 100644
index 000000000000..61bec1100a94
@@ -0,0 +1,59 @@
+Devicetree bindings for Maxim MAX9485 Programmable Audio Clock Generator
+
+This device exposes 4 clocks in total:
+
+- MAX9485_MCLKOUT: 	A gated, buffered output of the input clock of 27 MHz
+- MAX9485_CLKOUT:	A PLL that can be configured to 16 different discrete
+			frequencies
+- MAX9485_CLKOUT[1,2]:	Two gated outputs for MAX9485_CLKOUT
+
+MAX9485_CLKOUT[1,2] are children of MAX9485_CLKOUT which upchain all rate set
+requests.
+
+Required properties:
+- compatible:	"maxim,max9485"
+- clocks:	Input clock, must provice 27.000 MHz
+- clock-names:	Must be set to "xclk"
+- #clock-cells: From common clock binding; shall be set to 1
+
+Optional properties:
+- reset-gpios:		GPIO descriptor connected to the #RESET input pin
+- vdd-supply:		A regulator node for Vdd
+- clock-output-names:	Name of output clocks, as defined in common clock
+			bindings
+
+If not explicitly set, the output names are "mclkout", "clkout", "clkout1"
+and "clkout2".
+
+Clocks are defined as preprocessor macros in the dt-binding header.
+
+Example:
+
+	#include <dt-bindings/clock/maxim,max9485.h>
+
+	xo-27mhz: xo-27mhz {
+		compatible = "fixed-clock";
+		#clock-cells = <0>;
+		clock-frequency = <27000000>;
+	};
+
+	&i2c0 {
+		max9485: audio-clock@63 {
+			reg = <0x63>;
+			compatible = "maxim,max9485";
+			clock-names = "xclk";
+			clocks = <&xo-27mhz>;
+			reset-gpios = <&gpio 1 GPIO_ACTIVE_HIGH>;
+			vdd-supply = <&3v3-reg>;
+			#clock-cells = <1>;
+		};
+	};
+
+	// Clock consumer node
+
+	foo@0 {
+		compatible = "bar,foo";
+		/* ... */
+		clock-names = "foo-input-clk";
+		clocks = <&max9485 MAX9485_CLKOUT1>;
+	};
include/dt-bindings/clock/maxim,max9485.h new file +18 -0
new file mode 100644
index 000000000000..185b09ce1869
@@ -0,0 +1,18 @@
+/*
+ * Copyright (C) 2018 Daniel Mack
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ */
+
+#ifndef __DT_BINDINGS_MAX9485_CLK_H
+#define __DT_BINDINGS_MAX9485_CLK_H
+
+#define MAX9485_MCLKOUT	0
+#define MAX9485_CLKOUT	1
+#define MAX9485_CLKOUT1	2
+#define MAX9485_CLKOUT2	3
+
+#endif /* __DT_BINDINGS_MAX9485_CLK_H */
Signature · 1 line
2.14.3
#3 lore raw

PATCH v2 2/2 clk: Add driver for MAX9485

In reply to Daniel Mack

From: Daniel Mack <[email protected]>

This patch adds a driver for MAX9485, a programmable audio clock generator.

The device requires a 27.000 MHz clock input. It can provide a gated buffered output of its input clock and two gated outputs of a PLL that can generate one out of 16 discrete frequencies. There is only one PLL however, so the two gated outputs will always have the same frequency but they can be switched individually.

The driver for this device exposes 4 clocks in total:

- MAX9485_MCLKOUT: A gated, buffered output of the input clock
- MAX9485_CLKOUT: A PLL that can be configured to 16 different
discrete frequencies
- MAX9485_CLKOUT[1,2]: Two gated outputs for MAX9485_CLKOUT

Some PLL output frequencies can be achieved with different register settings. The driver will select the one with lowest jitter in such cases.

---
 drivers/clk/Kconfig       |   8 +
 drivers/clk/Makefile      |   1 +
 drivers/clk/clk-max9485.c | 408 ++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 417 insertions(+)
 create mode 100644 drivers/clk/clk-max9485.c
drivers/clk/Kconfig +8 -0
index 34968a381d0f..f8ab54c41d16 100644
@@ -45,6 +45,14 @@ config COMMON_CLK_MAX77686
 	  This driver supports Maxim 77620/77686/77802 crystal oscillator
 	  clock.
 
+config COMMON_CLK_MAX9485
+	tristate "Clock driver for Maxim 9485 Programmable Clock Generator"
+	depends on I2C
+	depends on OF
+	depends on GPIOLIB || COMPILE_TEST
+	---help---
+	  This driver supports Maxim 9485 Programmable Audio Clock Generator
+
 config COMMON_CLK_RK808
 	tristate "Clock driver for RK805/RK808/RK818"
 	depends on MFD_RK808
drivers/clk/Makefile +1 -0
index de6d06ac790b..27417ba3c1df 100644
@@ -31,6 +31,7 @@ obj-$(CONFIG_COMMON_CLK_ASPEED)		+= clk-aspeed.o
 obj-$(CONFIG_ARCH_HIGHBANK)		+= clk-highbank.o
 obj-$(CONFIG_CLK_HSDK)			+= clk-hsdk-pll.o
 obj-$(CONFIG_COMMON_CLK_MAX77686)	+= clk-max77686.o
+obj-$(CONFIG_COMMON_CLK_MAX9485)	+= clk-max9485.o
 obj-$(CONFIG_ARCH_MOXART)		+= clk-moxart.o
 obj-$(CONFIG_ARCH_NOMADIK)		+= clk-nomadik.o
 obj-$(CONFIG_ARCH_NSPIRE)		+= clk-nspire.o
drivers/clk/clk-max9485.c new file +408 -0

408 lines not on this page · raw message

Signature · 1 line
2.14.3
maintainer Reviewed-by on v2 1/2
#2 lore raw

Re: [PATCH v2 1/2] dts: clk: add devicetree bindings for MAX9485

In reply to Daniel Mack
Quoted 10 lines · Daniel Mack

This patch adds the devicetree bindings for MAX9485, a programmable audio clock generator.

---
 .../devicetree/bindings/clock/maxim,max9485.txt    | 59 ++++++++++++++++++++++
 include/dt-bindings/clock/maxim,max9485.h          | 18 +++++++
 2 files changed, 77 insertions(+)
 create mode 100644 Documentation/devicetree/bindings/clock/maxim,max9485.txt
 create mode 100644 include/dt-bindings/clock/maxim,max9485.h
#4 lore raw
In reply to Daniel Mack
Quoted 17 lines · Daniel Mack

From: Daniel Mack <[email protected]>

This patch adds a driver for MAX9485, a programmable audio clock generator.

The device requires a 27.000 MHz clock input. It can provide a gated buffered output of its input clock and two gated outputs of a PLL that can generate one out of 16 discrete frequencies. There is only one PLL however, so the two gated outputs will always have the same frequency but they can be switched individually.

The driver for this device exposes 4 clocks in total:

- MAX9485_MCLKOUT: A gated, buffered output of the input clock
- MAX9485_CLKOUT: A PLL that can be configured to 16 different
discrete frequencies
- MAX9485_CLKOUT[1,2]: Two gated outputs for MAX9485_CLKOUT

Quoted 4 lines

Some PLL output frequencies can be achieved with different register settings. The driver will select the one with lowest jitter in such cases.

Note that I've spotted a minor issue with the reset GPIO line handling that sneaked in in v2. I just didn't send v3 yet because I wanted to wait for more feedback on the implementation.

Thanks,
Daniel

Quoted 453 lines
---
  drivers/clk/Kconfig       |   8 +
  drivers/clk/Makefile      |   1 +
  drivers/clk/clk-max9485.c | 408 ++++++++++++++++++++++++++++++++++++++++++++++
  3 files changed, 417 insertions(+)

create mode 100644 drivers/clk/clk-max9485.c

drivers/clk/Kconfig +8 -0
index 34968a381d0f..f8ab54c41d16 100644
@@ -45,6 +45,14 @@ config COMMON_CLK_MAX77686
  	  This driver supports Maxim 77620/77686/77802 crystal oscillator
  	  clock.
 
+config COMMON_CLK_MAX9485
+	tristate "Clock driver for Maxim 9485 Programmable Clock Generator"
+	depends on I2C
+	depends on OF
+	depends on GPIOLIB || COMPILE_TEST
+	---help---
+	  This driver supports Maxim 9485 Programmable Audio Clock Generator
+
  config COMMON_CLK_RK808
  	tristate "Clock driver for RK805/RK808/RK818"
  	depends on MFD_RK808
drivers/clk/Makefile +1 -0
index de6d06ac790b..27417ba3c1df 100644
@@ -31,6 +31,7 @@ obj-$(CONFIG_COMMON_CLK_ASPEED)		+= clk-aspeed.o
  obj-$(CONFIG_ARCH_HIGHBANK)		+= clk-highbank.o
  obj-$(CONFIG_CLK_HSDK)			+= clk-hsdk-pll.o
  obj-$(CONFIG_COMMON_CLK_MAX77686)	+= clk-max77686.o
+obj-$(CONFIG_COMMON_CLK_MAX9485)	+= clk-max9485.o
  obj-$(CONFIG_ARCH_MOXART)		+= clk-moxart.o
  obj-$(CONFIG_ARCH_NOMADIK)		+= clk-nomadik.o
  obj-$(CONFIG_ARCH_NSPIRE)		+= clk-nspire.o
drivers/clk/clk-max9485.c new file +408 -0
new file mode 100644
index 000000000000..9bbf2fee49c5
@@ -0,0 +1,408 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * clk-max9485.c: MAX9485 Programmable Audio Clock Generator
+ *
+ * (c) 2018 Daniel Mack <[email protected]>
+ *
+ * References:
+ *   MAX9485 Datasheet
+ *     http://www.maximintegrated.com/datasheet/index.mvp/id/4421
+ *
+ * This program is free software; you can redistribute  it and/or modify it
+ * under  the terms of  the GNU General  Public License as published by the
+ * Free Software Foundation;  either version 2 of the  License, or (at your
+ * option) any later version.
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/clkdev.h>
+#include <linux/clk.h>
+#include <linux/clk-provider.h>
+#include <linux/err.h>
+#include <linux/errno.h>
+#include <linux/gpio/consumer.h>
+#include <linux/i2c.h>
+#include <linux/regulator/consumer.h>
+
+#include <dt-bindings/clock/maxim,max9485.h>
+
+#define MAX9485_INPUT_FREQ 27000000UL
+#define MAX9485_NUM_CLKS 4
+
+/* This chip has only one register of 8 bit width. */
+
+enum {
+	MAX9485_FS_12KHZ	= 0 << 0,
+	MAX9485_FS_32KHZ	= 1 << 0,
+	MAX9485_FS_44_1KHZ	= 2 << 0,
+	MAX9485_FS_48KHZ	= 3 << 0,
+};
+
+enum {
+	MAX9485_SCALE_256	= 0 << 2,
+	MAX9485_SCALE_384	= 1 << 2,
+	MAX9485_SCALE_768	= 2 << 2,
+};
+
+#define MAX9485_DOUBLE		BIT(4)
+#define MAX9485_CLKOUT1_ENABLE	BIT(5)
+#define MAX9485_CLKOUT2_ENABLE	BIT(6)
+#define MAX9485_MCLK_ENABLE	BIT(7)
+#define MAX9485_FREQ_MASK	0x1f
+
+struct max9485_rate {
+	unsigned long out;
+	u8 reg_value;
+};
+
+/*
+ * Ordered by frequency. For frequency the hardware can generate with
+ * multiple settings, only the one with lowest jitter is listed.
+ */
+static const struct max9485_rate max9485_rates[] = {
+	{  3072000, MAX9485_FS_12KHZ   | MAX9485_SCALE_256 },
+	{  4608000, MAX9485_FS_12KHZ   | MAX9485_SCALE_384 },
+	{  8192000, MAX9485_FS_32KHZ   | MAX9485_SCALE_256 },
+	{  9126000, MAX9485_FS_12KHZ   | MAX9485_SCALE_768 },
+	{ 11289600, MAX9485_FS_44_1KHZ | MAX9485_SCALE_256 },
+	{ 12288000, MAX9485_FS_48KHZ   | MAX9485_SCALE_256 },
+	{ 16384000, MAX9485_FS_32KHZ   | MAX9485_SCALE_256 | MAX9485_DOUBLE },
+	{ 16934400, MAX9485_FS_44_1KHZ | MAX9485_SCALE_384 },
+	{ 18384000, MAX9485_FS_48KHZ   | MAX9485_SCALE_384 },
+	{ 22579200, MAX9485_FS_44_1KHZ | MAX9485_SCALE_256 | MAX9485_DOUBLE },
+	{ 24576000, MAX9485_FS_48KHZ   | MAX9485_SCALE_256 | MAX9485_DOUBLE },
+	{ 33868800, MAX9485_FS_44_1KHZ | MAX9485_SCALE_384 | MAX9485_DOUBLE },
+	{ 36864000, MAX9485_FS_48KHZ   | MAX9485_SCALE_384 | MAX9485_DOUBLE },
+	{ 49152000, MAX9485_FS_32KHZ   | MAX9485_SCALE_768 | MAX9485_DOUBLE },
+	{ 67737600, MAX9485_FS_44_1KHZ | MAX9485_SCALE_768 | MAX9485_DOUBLE },
+	{ 73728000, MAX9485_FS_48KHZ   | MAX9485_SCALE_768 | MAX9485_DOUBLE },
+	{ } /* sentinel */
+};
+
+struct max9485_driver_data;
+
+struct max9485_clk_hw {
+	struct clk_hw hw;
+	struct clk_init_data init;
+	u8 enable_bit;
+	struct max9485_driver_data *drvdata;
+};
+
+struct max9485_driver_data {
+	struct clk *xclk;
+	struct i2c_client *client;
+	u8 reg_value;
+	unsigned long clkout_rate;
+	struct regulator *supply;
+	struct gpio_desc *reset_gpio;
+	struct max9485_clk_hw hw[MAX9485_NUM_CLKS];
+
+	struct {
+		struct clk_hw_onecell_data data;
+		struct clk_hw *hw[MAX9485_NUM_CLKS];
+	} onecell;
+};
+
+static int max9485_update_bits(struct max9485_driver_data *drvdata,
+			       u8 mask, u8 value)
+{
+	int ret;
+
+	drvdata->reg_value &= ~mask;
+	drvdata->reg_value |= value;
+
+	dev_dbg(&drvdata->client->dev,
+		"updating mask %02x value %02x -> %02x\n",
+		mask, value, drvdata->reg_value);
+
+	ret = i2c_master_send(drvdata->client,
+			      &drvdata->reg_value,
+			      sizeof(drvdata->reg_value));
+
+	return (ret < 0) ? ret : 0;
+}
+
+static int max9485_clk_prepare(struct clk_hw *hw)
+{
+	struct max9485_clk_hw *clk_hw =
+		container_of(hw, struct max9485_clk_hw, hw);
+
+	return max9485_update_bits(clk_hw->drvdata,
+				   clk_hw->enable_bit,
+				   clk_hw->enable_bit);
+}
+
+static void max9485_clk_unprepare(struct clk_hw *hw)
+{
+	struct max9485_clk_hw *clk_hw =
+		container_of(hw, struct max9485_clk_hw, hw);
+
+	max9485_update_bits(clk_hw->drvdata, clk_hw->enable_bit, 0);
+}
+
+/*
+ * MCLK OUT
+ */
+
+/* The MCLK output can only provide the same rate as the input clock */
+static unsigned long max9485_mclkout_recalc_rate(struct clk_hw *hw,
+						 unsigned long parent_rate)
+{
+	return MAX9485_INPUT_FREQ;
+}
+
+/*
+ * CLKOUT - configurable clock output
+ */
+static int max9485_clkout_set_rate(struct clk_hw *hw, unsigned long rate,
+				   unsigned long parent_rate)
+{
+	const struct max9485_rate *entry;
+	struct max9485_clk_hw *clk_hw =
+		container_of(hw, struct max9485_clk_hw, hw);
+
+	for (entry = max9485_rates; entry->out != 0; entry++)
+		if (entry->out == rate)
+			break;
+
+	if (entry->out == 0)
+		return -EINVAL;
+
+	clk_hw->drvdata->clkout_rate = rate;
+
+	return max9485_update_bits(clk_hw->drvdata,
+				   MAX9485_FREQ_MASK,
+				   entry->reg_value);
+}
+
+static long max9485_clkout_round_rate(struct clk_hw *hw, unsigned long rate,
+				      unsigned long *parent_rate)
+{
+	const struct max9485_rate *curr, *prev = NULL;
+
+	for (curr = max9485_rates; curr->out != 0; curr++) {
+		/* Exact matches */
+		if (curr->out == rate)
+			return rate;
+
+		/*
+		 * Find the first entry that has a frequency higher than the
+		 * requested one.
+		 */
+		if (curr->out > rate) {
+			unsigned int mid;
+
+			/*
+			 * If this is the first entry, clamp the value to the
+			 * lowest possible frequency.
+			 */
+			if (!prev)
+				return curr->out;
+
+			/*
+			 * Otherwise, determine whether the previous entry or
+			 * current one is closer.
+			 */
+			mid = prev->out + ((curr->out - prev->out) / 2);
+
+			return (mid > rate) ? prev->out : curr->out;
+		}
+
+		prev = curr;
+	}
+
+	/* If the last entry was still too high, clamp the value */
+	return prev->out;
+}
+
+static unsigned long max9485_clkout_recalc_rate(struct clk_hw *hw,
+						unsigned long parent_rate)
+{
+	struct max9485_clk_hw *clk_hw =
+		container_of(hw, struct max9485_clk_hw, hw);
+
+	return clk_hw->drvdata->clkout_rate;
+}
+
+struct max9485_clk {
+	const char *name;
+	int parent_index;
+	const struct clk_ops ops;
+	u8 enable_bit;
+};
+
+static const struct max9485_clk max9485_clks[MAX9485_NUM_CLKS] = {
+	[MAX9485_MCLKOUT] = {
+		.name = "mclkout",
+		.parent_index = -1,
+		.enable_bit = MAX9485_MCLK_ENABLE,
+		.ops = {
+			.prepare	= max9485_clk_prepare,
+			.unprepare	= max9485_clk_unprepare,
+			.recalc_rate	= max9485_mclkout_recalc_rate,
+		},
+	},
+	[MAX9485_CLKOUT] = {
+		.name = "clkout",
+		.parent_index = -1,
+		.ops = {
+			.set_rate	= max9485_clkout_set_rate,
+			.round_rate	= max9485_clkout_round_rate,
+			.recalc_rate	= max9485_clkout_recalc_rate,
+		},
+	},
+	[MAX9485_CLKOUT1] = {
+		.name = "clkout1",
+		.parent_index = MAX9485_CLKOUT,
+		.enable_bit = MAX9485_CLKOUT1_ENABLE,
+		.ops = {
+			.prepare	= max9485_clk_prepare,
+			.unprepare	= max9485_clk_unprepare,
+			.recalc_rate	= max9485_clkout_recalc_rate,
+		},
+	},
+	[MAX9485_CLKOUT2] = {
+		.name = "clkout2",
+		.parent_index = MAX9485_CLKOUT,
+		.enable_bit = MAX9485_CLKOUT2_ENABLE,
+		.ops = {
+			.prepare	= max9485_clk_prepare,
+			.unprepare	= max9485_clk_unprepare,
+			.recalc_rate	= max9485_clkout_recalc_rate,
+		},
+	},
+};
+
+static int max9485_i2c_probe(struct i2c_client *client,
+			     const struct i2c_device_id *id)
+{
+	struct max9485_driver_data *drvdata;
+	struct device *dev = &client->dev;
+	unsigned long freq;
+	int i, ret;
+
+	drvdata = devm_kzalloc(dev, sizeof(*drvdata), GFP_KERNEL);
+	if (drvdata == NULL)
+		return -ENOMEM;
+
+	drvdata->xclk = devm_clk_get(dev, "xclk");
+	if (IS_ERR(drvdata->xclk))
+		return PTR_ERR(drvdata->xclk);
+
+	freq = clk_get_rate(drvdata->xclk);
+	if (freq != MAX9485_INPUT_FREQ) {
+		dev_err(dev, "Illegal xclk frequency of %ld\n", freq);
+		return -EINVAL;
+	}
+
+	drvdata->supply = devm_regulator_get(dev, "vdd");
+	if (IS_ERR(drvdata->supply))
+		return PTR_ERR(drvdata->supply);
+
+	ret = regulator_enable(drvdata->supply);
+	if (ret < 0)
+		return ret;
+
+	drvdata->reset_gpio =
+		devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_HIGH);
+	if (IS_ERR(drvdata->reset_gpio))
+		return PTR_ERR(drvdata->reset_gpio);
+
+	i2c_set_clientdata(client, drvdata);
+	drvdata->client = client;
+
+	for (i = 0; i < MAX9485_NUM_CLKS; i++) {
+		int parent_index = max9485_clks[i].parent_index;
+		const char *name;
+
+		if (of_property_read_string_index(dev->of_node,
+						  "clock-output-names",
+						  i, &name) == 0)
+			drvdata->hw[i].init.name = name;
+		else
+			drvdata->hw[i].init.name = max9485_clks[i].name;
+
+		drvdata->hw[i].init.ops = &max9485_clks[i].ops;
+		drvdata->hw[i].init.flags = CLK_IS_BASIC;
+
+		if (parent_index > 0) {
+			drvdata->hw[i].init.parent_names =
+				&drvdata->hw[parent_index].init.name;
+			drvdata->hw[i].init.num_parents = 1;
+			drvdata->hw[i].init.flags |= CLK_SET_RATE_PARENT;
+		}
+
+		drvdata->hw[i].enable_bit = max9485_clks[i].enable_bit;
+		drvdata->hw[i].hw.init = &drvdata->hw[i].init;
+		drvdata->hw[i].drvdata = drvdata;
+
+		ret = devm_clk_hw_register(dev, &drvdata->hw[i].hw);
+		if (ret < 0)
+			return ret;
+
+		drvdata->onecell.hw[i] = &drvdata->hw[i].hw;
+	}
+
+	drvdata->onecell.data.num = MAX9485_NUM_CLKS;
+
+	return devm_of_clk_add_hw_provider(dev, of_clk_hw_onecell_get,
+					   &drvdata->onecell.data);
+}
+
+static int __maybe_unused max9485_suspend(struct device *dev)
+{
+	struct i2c_client *client = to_i2c_client(dev);
+	struct max9485_driver_data *drvdata = i2c_get_clientdata(client);
+
+	if (drvdata->reset_gpio)
+		gpiod_set_value_cansleep(drvdata->reset_gpio, 0);
+
+	return 0;
+}
+
+static int __maybe_unused max9485_resume(struct device *dev)
+{
+	struct i2c_client *client = to_i2c_client(dev);
+	struct max9485_driver_data *drvdata = i2c_get_clientdata(client);
+	int ret;
+
+	if (drvdata->reset_gpio)
+		gpiod_set_value_cansleep(drvdata->reset_gpio, 0);
+
+	ret = i2c_master_send(client, &drvdata->reg_value,
+			      sizeof(drvdata->reg_value));
+
+	return (ret < 0) ? ret : 0;
+}
+
+static const struct dev_pm_ops max9485_pm_ops = {
+	SET_SYSTEM_SLEEP_PM_OPS(max9485_suspend, max9485_resume)
+};
+
+static const struct of_device_id max9485_dt_ids[] = {
+	{ .compatible = "maxim,max9485", },
+	{ }
+};
+MODULE_DEVICE_TABLE(of, max9485_dt_ids);
+
+static const struct i2c_device_id max9485_i2c_ids[] = {
+	{ .name = "max9485", },
+	{ }
+};
+MODULE_DEVICE_TABLE(i2c, max9485_i2c_ids);
+
+static struct i2c_driver max9485_driver = {
+	.driver = {
+		.name		= "max9485",
+		.pm		= &max9485_pm_ops,
+		.of_match_table	= max9485_dt_ids,
+	},
+	.probe = max9485_i2c_probe,
+	.id_table = max9485_i2c_ids,
+};
+module_i2c_driver(max9485_driver);
+
+MODULE_AUTHOR("Daniel Mack <[email protected]>");
+MODULE_DESCRIPTION("MAX9485 Programmable Audio Clock Generator");
+MODULE_LICENSE("GPL v2");
maintainer
#5 lore raw
In reply to Daniel Mack

Quoting Daniel Mack (2018-05-25 11:20:58)

drivers/clk/Kconfig config COMMON_CLK_MAX77686 · line 50

Quoted 11 lines
drivers/clk/Kconfig +2 -0
index 34968a381d0f..f8ab54c41d16 100644
@@ -45,6 +45,14 @@ config COMMON_CLK_MAX77686
          This driver supports Maxim 77620/77686/77802 crystal oscillator
          clock.
 =
 
+config COMMON_CLK_MAX9485
+       tristate "Clock driver for Maxim 9485 Programmable Clock Generato=

r"

drivers/clk/Kconfig config COMMON_CLK_MAX77686 · line 51

Quoted 2 lines
drivers/clk/Kconfig +2 -0
+       depends on I2C
+       depends on OF

Drop this depends? Probably not needed to compile this driver.

drivers/clk/Kconfig config COMMON_CLK_MAX77686 · line 52

Quoted 1 line
drivers/clk/Kconfig +1 -0
+       depends on GPIOLIB || COMPILE_TEST

Is this common? I never knew.

drivers/clk/Kconfig config COMMON_CLK_MAX77686 · line 55

Quoted 2 lines
drivers/clk/Kconfig +2 -0
+       ---help---
+         This driver supports Maxim 9485 Programmable Audio Clock Genera=

tor

Quoted 11 lines
drivers/clk/Kconfig +1 -0
+
 config COMMON_CLK_RK808
        tristate "Clock driver for RK805/RK808/RK818"

depends on MFD_RK808

drivers/clk/clk-max9485.c new file +1 -0
new file mode 100644
index 000000000000..9bbf2fee49c5
@@ -0,0 +1,408 @@
+// SPDX-License-Identifier: GPL-2.0

drivers/clk/clk-max9485.c line 11

Quoted 10 lines
drivers/clk/clk-max9485.c new file +10 -0
+/*
+ * clk-max9485.c: MAX9485 Programmable Audio Clock Generator
+ *
+ * (c) 2018 Daniel Mack <[email protected]>
+ *
+ * References:
+ *   MAX9485 Datasheet
+ *     http://www.maximintegrated.com/datasheet/index.mvp/id/4421
+ *
+ * This program is free software; you can redistribute  it and/or modify=

it

drivers/clk/clk-max9485.c line 12

Quoted 1 line
drivers/clk/clk-max9485.c new file +1 -0
+ * under  the terms of  the GNU General  Public License as published by =

the

drivers/clk/clk-max9485.c line 13

Quoted 1 line
drivers/clk/clk-max9485.c new file +1 -0
+ * Free Software Foundation;  either version 2 of the  License, or (at y=

our

drivers/clk/clk-max9485.c line 19

Quoted 6 lines
drivers/clk/clk-max9485.c new file +6 -0
+ * option) any later version.
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/clkdev.h>

Is this used?

Quoted 4 lines
drivers/clk/clk-max9485.c new file +4 -0
+#include <linux/clk.h>
+#include <linux/clk-provider.h>
+#include <linux/err.h>
+#include <linux/errno.h>

drivers/clk/clk-max9485.c line 33

Quoted 10 lines
drivers/clk/clk-max9485.c new file +10 -0
+#include <linux/gpio/consumer.h>
+#include <linux/i2c.h>
+#include <linux/regulator/consumer.h>
+
+#include <dt-bindings/clock/maxim,max9485.h>
+
+#define MAX9485_INPUT_FREQ 27000000UL
+#define MAX9485_NUM_CLKS 4
+
+/* This chip has only one register of 8 bit width. */

So efficient!

drivers/clk/clk-max9485.c line 46

Quoted 13 lines
drivers/clk/clk-max9485.c new file +13 -0
+
+enum {
+       MAX9485_FS_12KHZ        =3D 0 << 0,
+       MAX9485_FS_32KHZ        =3D 1 << 0,
+       MAX9485_FS_44_1KHZ      =3D 2 << 0,
+       MAX9485_FS_48KHZ        =3D 3 << 0,
+};
+
+enum {
+       MAX9485_SCALE_256       =3D 0 << 2,
+       MAX9485_SCALE_384       =3D 1 << 2,
+       MAX9485_SCALE_768       =3D 2 << 2,
+};

Any reason to be an enum? Maybe they can just be #defines.

Quoted 14 lines
drivers/clk/clk-max9485.c new file +14 -0
+
+#define MAX9485_DOUBLE         BIT(4)
+#define MAX9485_CLKOUT1_ENABLE BIT(5)
+#define MAX9485_CLKOUT2_ENABLE BIT(6)
+#define MAX9485_MCLK_ENABLE    BIT(7)
+#define MAX9485_FREQ_MASK      0x1f
+
+struct max9485_rate {
+       unsigned long out;
+       u8 reg_value;
+};
+
+/*
+ * Ordered by frequency. For frequency the hardware can generate with

drivers/clk/clk-max9485.c

Quoted 10 lines
drivers/clk/clk-max9485.c new file +10 -0
+ * multiple settings, only the one with lowest jitter is listed.
+ */
+static const struct max9485_rate max9485_rates[] =3D {
+       {  3072000, MAX9485_FS_12KHZ   | MAX9485_SCALE_256 },
+       {  4608000, MAX9485_FS_12KHZ   | MAX9485_SCALE_384 },
+       {  8192000, MAX9485_FS_32KHZ   | MAX9485_SCALE_256 },
+       {  9126000, MAX9485_FS_12KHZ   | MAX9485_SCALE_768 },
+       { 11289600, MAX9485_FS_44_1KHZ | MAX9485_SCALE_256 },
+       { 12288000, MAX9485_FS_48KHZ   | MAX9485_SCALE_256 },
+       { 16384000, MAX9485_FS_32KHZ   | MAX9485_SCALE_256 | MAX9485_DOUB=

LE },

drivers/clk/clk-max9485.c

Quoted 3 lines
drivers/clk/clk-max9485.c new file +3 -0
+       { 16934400, MAX9485_FS_44_1KHZ | MAX9485_SCALE_384 },
+       { 18384000, MAX9485_FS_48KHZ   | MAX9485_SCALE_384 },
+       { 22579200, MAX9485_FS_44_1KHZ | MAX9485_SCALE_256 | MAX9485_DOUB=

LE },

drivers/clk/clk-max9485.c line 74

Quoted 1 line
drivers/clk/clk-max9485.c new file +1 -0
+       { 24576000, MAX9485_FS_48KHZ   | MAX9485_SCALE_256 | MAX9485_DOUB=

LE },

drivers/clk/clk-max9485.c line 75

Quoted 1 line
drivers/clk/clk-max9485.c new file +1 -0
+       { 33868800, MAX9485_FS_44_1KHZ | MAX9485_SCALE_384 | MAX9485_DOUB=

LE },

drivers/clk/clk-max9485.c line 76

Quoted 1 line
drivers/clk/clk-max9485.c new file +1 -0
+       { 36864000, MAX9485_FS_48KHZ   | MAX9485_SCALE_384 | MAX9485_DOUB=

LE },

drivers/clk/clk-max9485.c line 77

Quoted 1 line
drivers/clk/clk-max9485.c new file +1 -0
+       { 49152000, MAX9485_FS_32KHZ   | MAX9485_SCALE_768 | MAX9485_DOUB=

LE },

drivers/clk/clk-max9485.c line 78

Quoted 1 line
drivers/clk/clk-max9485.c new file +1 -0
+       { 67737600, MAX9485_FS_44_1KHZ | MAX9485_SCALE_768 | MAX9485_DOUB=

LE },

drivers/clk/clk-max9485.c line 79

Quoted 1 line
drivers/clk/clk-max9485.c new file +1 -0
+       { 73728000, MAX9485_FS_48KHZ   | MAX9485_SCALE_768 | MAX9485_DOUB=

LE },

Quoted 14 lines
drivers/clk/clk-max9485.c new file +14 -0
+       { } /* sentinel */
+};
+
+struct max9485_driver_data;
+
+struct max9485_clk_hw {
+       struct clk_hw hw;
+       struct clk_init_data init;
+       u8 enable_bit;
+       struct max9485_driver_data *drvdata;
+};
+
+struct max9485_driver_data {
+       struct clk *xclk;

drivers/clk/clk-max9485.c line 103

Quoted 10 lines
drivers/clk/clk-max9485.c new file +10 -0
+       struct i2c_client *client;
+       u8 reg_value;
+       unsigned long clkout_rate;
+       struct regulator *supply;
+       struct gpio_desc *reset_gpio;
+       struct max9485_clk_hw hw[MAX9485_NUM_CLKS];
+
+       struct {
+               struct clk_hw_onecell_data data;
+               struct clk_hw *hw[MAX9485_NUM_CLKS];

I don't quite understand this one. There's already an array of clk_hw pointers inside of clk_hw_onecell_data so just use that? But then there's also an array of max9485_clk_hw structures, so maybe roll your own clk_hw getter function?

Quoted 8 lines
drivers/clk/clk-max9485.c new file +8 -0
+       } onecell;
+};
+
+static int max9485_update_bits(struct max9485_driver_data *drvdata,
+                              u8 mask, u8 value)
+{
+       int ret;
+

drivers/clk/clk-max9485.c line 121

Quoted 10 lines
drivers/clk/clk-max9485.c new file +10 -0
+       drvdata->reg_value &=3D ~mask;
+       drvdata->reg_value |=3D value;
+
+       dev_dbg(&drvdata->client->dev,
+               "updating mask %02x value %02x -> %02x\n",
+               mask, value, drvdata->reg_value);
+
+       ret =3D i2c_master_send(drvdata->client,
+                             &drvdata->reg_value,
+                             sizeof(drvdata->reg_value));

Maybe use a regmap instead? Then you could use regmap_update_bits() in the places you need it.

drivers/clk/clk-max9485.c line 129

Quoted 8 lines
drivers/clk/clk-max9485.c new file +8 -0
+
+       return (ret < 0) ? ret : 0;
+}
+
+static int max9485_clk_prepare(struct clk_hw *hw)
+{
+       struct max9485_clk_hw *clk_hw =3D
+               container_of(hw, struct max9485_clk_hw, hw);

Please make a static inline function for this line called something like to_max8458_clk().

Quoted 11 lines
drivers/clk/clk-max9485.c new file +11 -0
+
+       return max9485_update_bits(clk_hw->drvdata,
+                                  clk_hw->enable_bit,
+                                  clk_hw->enable_bit);
+}
+
+static void max9485_clk_unprepare(struct clk_hw *hw)
+{
+       struct max9485_clk_hw *clk_hw =3D
+               container_of(hw, struct max9485_clk_hw, hw);
+

drivers/clk/clk-max9485.c

Quoted 10 lines
drivers/clk/clk-max9485.c new file +10 -0
+       max9485_update_bits(clk_hw->drvdata, clk_hw->enable_bit, 0);
+}
+
+/*
+ * MCLK OUT
+ */
+
+/* The MCLK output can only provide the same rate as the input clock */
+static unsigned long max9485_mclkout_recalc_rate(struct clk_hw *hw,
+                                                unsigned long parent_rat=

e)

drivers/clk/clk-max9485.c line 153

Quoted 3 lines
drivers/clk/clk-max9485.c new file +3 -0
+{
+       return MAX9485_INPUT_FREQ;
+}

This clk_op can be dropped and just rely on parent frequency.

Quoted 13 lines
drivers/clk/clk-max9485.c new file +13 -0
+
+/*
+ * CLKOUT - configurable clock output
+ */
+static int max9485_clkout_set_rate(struct clk_hw *hw, unsigned long rate,
+                                  unsigned long parent_rate)
+{
+       const struct max9485_rate *entry;
+       struct max9485_clk_hw *clk_hw =3D
+               container_of(hw, struct max9485_clk_hw, hw);
+
+       for (entry =3D max9485_rates; entry->out !=3D 0; entry++)
+               if (entry->out =3D=3D rate)

drivers/clk/clk-max9485.c line 176

Quoted 10 lines
drivers/clk/clk-max9485.c new file +10 -0
+                       break;
+
+       if (entry->out =3D=3D 0)
+               return -EINVAL;
+
+       clk_hw->drvdata->clkout_rate =3D rate;
+
+       return max9485_update_bits(clk_hw->drvdata,
+                                  MAX9485_FREQ_MASK,
+                                  entry->reg_value);

Need to unwind clkout_rate on failure? clkout_rate should go away actually.

drivers/clk/clk-max9485.c

Quoted 3 lines
drivers/clk/clk-max9485.c new file +3 -0
+}
+
+static long max9485_clkout_round_rate(struct clk_hw *hw, unsigned long r=

ate,

drivers/clk/clk-max9485.c

Quoted 11 lines
drivers/clk/clk-max9485.c new file +11 -0
+                                     unsigned long *parent_rate)
+{
+       const struct max9485_rate *curr, *prev =3D NULL;
+
+       for (curr =3D max9485_rates; curr->out !=3D 0; curr++) {
+               /* Exact matches */
+               if (curr->out =3D=3D rate)
+                       return rate;
+
+               /*
+                * Find the first entry that has a frequency higher than =

the

drivers/clk/clk-max9485.c

Quoted 7 lines
drivers/clk/clk-max9485.c new file +7 -0
+                * requested one.
+                */
+               if (curr->out > rate) {
+                       unsigned int mid;
+
+                       /*
+                        * If this is the first entry, clamp the value to=

the

drivers/clk/clk-max9485.c

Quoted 7 lines
drivers/clk/clk-max9485.c new file +7 -0
+                        * lowest possible frequency.
+                        */
+                       if (!prev)
+                               return curr->out;
+
+                       /*
+                        * Otherwise, determine whether the previous entr=

y or

Quoted 11 lines
drivers/clk/clk-max9485.c new file +11 -0
+                        * current one is closer.
+                        */
+                       mid =3D prev->out + ((curr->out - prev->out) / 2);
+
+                       return (mid > rate) ? prev->out : curr->out;
+               }
+
+               prev =3D curr;
+       }
+
+       /* If the last entry was still too high, clamp the value */

drivers/clk/clk-max9485.c line 225

Quoted 10 lines
drivers/clk/clk-max9485.c new file +10 -0
+       return prev->out;
+}
+
+static unsigned long max9485_clkout_recalc_rate(struct clk_hw *hw,
+                                               unsigned long parent_rate)
+{
+       struct max9485_clk_hw *clk_hw =3D
+               container_of(hw, struct max9485_clk_hw, hw);
+
+       return clk_hw->drvdata->clkout_rate;

This needs to return the rate of the clk that's determined by reading the hardware. Caching the rate yourself is hard and error prone, so you should only do it if you really have to.

Quoted 51 lines
drivers/clk/clk-max9485.c new file +51 -0
+}
+
+struct max9485_clk {
+       const char *name;
+       int parent_index;
+       const struct clk_ops ops;
+       u8 enable_bit;
+};
+
+static const struct max9485_clk max9485_clks[MAX9485_NUM_CLKS] =3D {
+       [MAX9485_MCLKOUT] =3D {
+               .name =3D "mclkout",
+               .parent_index =3D -1,
+               .enable_bit =3D MAX9485_MCLK_ENABLE,
+               .ops =3D {
+                       .prepare        =3D max9485_clk_prepare,
+                       .unprepare      =3D max9485_clk_unprepare,
+                       .recalc_rate    =3D max9485_mclkout_recalc_rate,
+               },
+       },
+       [MAX9485_CLKOUT] =3D {
+               .name =3D "clkout",
+               .parent_index =3D -1,
+               .ops =3D {
+                       .set_rate       =3D max9485_clkout_set_rate,
+                       .round_rate     =3D max9485_clkout_round_rate,
+                       .recalc_rate    =3D max9485_clkout_recalc_rate,
+               },
+       },
+       [MAX9485_CLKOUT1] =3D {
+               .name =3D "clkout1",
+               .parent_index =3D MAX9485_CLKOUT,
+               .enable_bit =3D MAX9485_CLKOUT1_ENABLE,
+               .ops =3D {
+                       .prepare        =3D max9485_clk_prepare,
+                       .unprepare      =3D max9485_clk_unprepare,
+                       .recalc_rate    =3D max9485_clkout_recalc_rate,
+               },
+       },
+       [MAX9485_CLKOUT2] =3D {
+               .name =3D "clkout2",
+               .parent_index =3D MAX9485_CLKOUT,
+               .enable_bit =3D MAX9485_CLKOUT2_ENABLE,
+               .ops =3D {
+                       .prepare        =3D max9485_clk_prepare,
+                       .unprepare      =3D max9485_clk_unprepare,
+                       .recalc_rate    =3D max9485_clkout_recalc_rate,
+               },
+       },
+};
+

drivers/clk/clk-max9485.c line 286

Quoted 10 lines
drivers/clk/clk-max9485.c new file +10 -0
+static int max9485_i2c_probe(struct i2c_client *client,
+                            const struct i2c_device_id *id)
+{
+       struct max9485_driver_data *drvdata;
+       struct device *dev =3D &client->dev;
+       unsigned long freq;
+       int i, ret;
+
+       drvdata =3D devm_kzalloc(dev, sizeof(*drvdata), GFP_KERNEL);
+       if (drvdata =3D=3D NULL)

More standard form is =

	if (!drvdata)
		return -ENOMEM;

drivers/clk/clk-max9485.c line 297

Quoted 11 lines
drivers/clk/clk-max9485.c new file +11 -0
+               return -ENOMEM;
+
+       drvdata->xclk =3D devm_clk_get(dev, "xclk");
+       if (IS_ERR(drvdata->xclk))
+               return PTR_ERR(drvdata->xclk);
+
+       freq =3D clk_get_rate(drvdata->xclk);
+       if (freq !=3D MAX9485_INPUT_FREQ) {
+               dev_err(dev, "Illegal xclk frequency of %ld\n", freq);
+               return -EINVAL;
+       }

Is this necessary? Seems pretty useless to do everywhere to make sure that someone didn't design the hardware incorrectly. It would be better to return the rate of the parent "xclk" by not having a recalc_rate hook and relying on the parent's rate.

Quoted 17 lines
drivers/clk/clk-max9485.c new file +17 -0
+
+       drvdata->supply =3D devm_regulator_get(dev, "vdd");
+       if (IS_ERR(drvdata->supply))
+               return PTR_ERR(drvdata->supply);
+
+       ret =3D regulator_enable(drvdata->supply);
+       if (ret < 0)
+               return ret;
+
+       drvdata->reset_gpio =3D
+               devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_HIGH);
+       if (IS_ERR(drvdata->reset_gpio))
+               return PTR_ERR(drvdata->reset_gpio);
+
+       i2c_set_clientdata(client, drvdata);
+       drvdata->client =3D client;
+

drivers/clk/clk-max9485.c

Quoted 10 lines
drivers/clk/clk-max9485.c new file +10 -0
+       for (i =3D 0; i < MAX9485_NUM_CLKS; i++) {
+               int parent_index =3D max9485_clks[i].parent_index;
+               const char *name;
+
+               if (of_property_read_string_index(dev->of_node,
+                                                 "clock-output-names",
+                                                 i, &name) =3D=3D 0)
+                       drvdata->hw[i].init.name =3D name;
+               else
+                       drvdata->hw[i].init.name =3D max9485_clks[i].name;

Add braces on both arms please.

drivers/clk/clk-max9485.c line 327

Quoted 3 lines
drivers/clk/clk-max9485.c new file +3 -0
+
+               drvdata->hw[i].init.ops =3D &max9485_clks[i].ops;
+               drvdata->hw[i].init.flags =3D CLK_IS_BASIC;

Don't use this flag unless you need it. Let me go add a comment to that effect to the code right now.

drivers/clk/clk-max9485.c

Quoted 6 lines
drivers/clk/clk-max9485.c new file +6 -0
+
+               if (parent_index > 0) {
+                       drvdata->hw[i].init.parent_names =3D
+                               &drvdata->hw[parent_index].init.name;
+                       drvdata->hw[i].init.num_parents =3D 1;
+                       drvdata->hw[i].init.flags |=3D CLK_SET_RATE_PAREN=

T;

Quoted 13 lines
drivers/clk/clk-max9485.c new file +13 -0
+               }
+
+               drvdata->hw[i].enable_bit =3D max9485_clks[i].enable_bit;
+               drvdata->hw[i].hw.init =3D &drvdata->hw[i].init;
+               drvdata->hw[i].drvdata =3D drvdata;
+
+               ret =3D devm_clk_hw_register(dev, &drvdata->hw[i].hw);
+               if (ret < 0)
+                       return ret;
+
+               drvdata->onecell.hw[i] =3D &drvdata->hw[i].hw;
+       }
+

drivers/clk/clk-max9485.c

Quoted 10 lines
drivers/clk/clk-max9485.c new file +10 -0
+       drvdata->onecell.data.num =3D MAX9485_NUM_CLKS;
+
+       return devm_of_clk_add_hw_provider(dev, of_clk_hw_onecell_get,
+                                          &drvdata->onecell.data);
+}
+
+static int __maybe_unused max9485_suspend(struct device *dev)
+{
+       struct i2c_client *client =3D to_i2c_client(dev);
+       struct max9485_driver_data *drvdata =3D i2c_get_clientdata(client=

);

drivers/clk/clk-max9485.c line 359

Quoted 3 lines
drivers/clk/clk-max9485.c new file +3 -0
+
+       if (drvdata->reset_gpio)
+               gpiod_set_value_cansleep(drvdata->reset_gpio, 0);

Looks like you can call this unconditionally if the gpio is not there because get_optional will return NULL and this function will bail out early if so.

drivers/clk/clk-max9485.c

Quoted 8 lines
drivers/clk/clk-max9485.c new file +8 -0
+
+       return 0;
+}
+
+static int __maybe_unused max9485_resume(struct device *dev)
+{
+       struct i2c_client *client =3D to_i2c_client(dev);
+       struct max9485_driver_data *drvdata =3D i2c_get_clientdata(client=

);

drivers/clk/clk-max9485.c line 372

Quoted 5 lines
drivers/clk/clk-max9485.c new file +5 -0
+       int ret;
+
+       if (drvdata->reset_gpio)
+               gpiod_set_value_cansleep(drvdata->reset_gpio, 0);
+

Same.

drivers/clk/clk-max9485.c line 123

Quoted 4 lines
drivers/clk/clk-max9485.c new file +4 -0
+       ret =3D i2c_master_send(client, &drvdata->reg_value,
+                             sizeof(drvdata->reg_value));
+
+       return (ret < 0) ? ret : 0;

Drop the extra parenthesis please.

Quoted 2 lines
drivers/clk/clk-max9485.c new file +2 -0
+}
+
#6 lore raw

Hi Stephen,

Thanks for the review!

Quoted 16 lines · Stephen Boyd

Quoting Daniel Mack (2018-05-25 11:20:58)

drivers/clk/clk-max9485.c line 46

Quoted 12 lines
drivers/clk/clk-max9485.c new file +12 -0
+enum {
+       MAX9485_FS_12KHZ        = 0 << 0,
+       MAX9485_FS_32KHZ        = 1 << 0,
+       MAX9485_FS_44_1KHZ      = 2 << 0,
+       MAX9485_FS_48KHZ        = 3 << 0,
+};
+
+enum {
+       MAX9485_SCALE_256       = 0 << 2,
+       MAX9485_SCALE_384       = 1 << 2,
+       MAX9485_SCALE_768       = 2 << 2,
+};

Any reason to be an enum? Maybe they can just be #defines.

No particular reason, but an enum shows these values are grouped together. But I can also turn them into defines, it's just a matter of taste I guess.

Quoted 9 lines
Quoted 9 lines
drivers/clk/clk-max9485.c new file +9 -0
+struct max9485_driver_data {
+       struct clk *xclk;
+       struct i2c_client *client;
+       u8 reg_value;
+       unsigned long clkout_rate;
+       struct regulator *supply;
+       struct gpio_desc *reset_gpio;
+       struct max9485_clk_hw hw[MAX9485_NUM_CLKS];
+
Quoted 8 lines

drivers/clk/clk-max9485.c line 103

Quoted 3 lines
drivers/clk/clk-max9485.c new file +3 -0
+       struct {
+               struct clk_hw_onecell_data data;
+               struct clk_hw *hw[MAX9485_NUM_CLKS];

I don't quite understand this one. There's already an array of clk_hw pointers inside of clk_hw_onecell_data so just use that? But then there's also an array of max9485_clk_hw structures, so maybe roll your own clk_hw getter function?

Ah, yes. The latter makes most sense. I was somehow stuck with the idea that the onecell helper makes sense here. Thanks for the heads-up.

Quoted 10 lines
Quoted 10 lines
drivers/clk/clk-max9485.c new file +10 -0
+static int max9485_update_bits(struct max9485_driver_data *drvdata,
+                              u8 mask, u8 value)
+{
+       int ret;
+
+       drvdata->reg_value &= ~mask;
+       drvdata->reg_value |= value;
+
+       dev_dbg(&drvdata->client->dev,
+               "updating mask %02x value %02x -> %02x\n",
Quoted 8 lines

drivers/clk/clk-max9485.c line 121

Quoted 5 lines
drivers/clk/clk-max9485.c new file +5 -0
+               mask, value, drvdata->reg_value);
+
+       ret = i2c_master_send(drvdata->client,
+                             &drvdata->reg_value,
+                             sizeof(drvdata->reg_value));

Maybe use a regmap instead? Then you could use regmap_update_bits() in the places you need it.

I wish, but nope, regmap doesn't work for devices that don't actually have registers, like this one. There's no extra byte for a register address or such, just one plain byte of payload.

[...]

Quoted 8 lines
Quoted 8 lines
drivers/clk/clk-max9485.c new file +8 -0
+               return -ENOMEM;
+
+       drvdata->xclk = devm_clk_get(dev, "xclk");
+       if (IS_ERR(drvdata->xclk))
+               return PTR_ERR(drvdata->xclk);
+
+       freq = clk_get_rate(drvdata->xclk);
+       if (freq != MAX9485_INPUT_FREQ) {
Quoted 8 lines

drivers/clk/clk-max9485.c line 297

Quoted 3 lines
drivers/clk/clk-max9485.c new file +3 -0
+               dev_err(dev, "Illegal xclk frequency of %ld\n", freq);
+               return -EINVAL;
+       }

Is this necessary? Seems pretty useless to do everywhere to make sure that someone didn't design the hardware incorrectly. It would be better to return the rate of the parent "xclk" by not having a recalc_rate hook and relying on the parent's rate.

Hmm, but the hardware doesn't work if the clock is anything else than 27.0MHz. But I'll remove the check no problem. After all, we don't check the regulator voltages either.

I've addressed all other comments. Will resend v3.

Thanks again!
Daniel