[u-boot.git] / drivers / misc / k3_avs.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * Texas Instruments' K3 Clas 0 Adaptive Voltage Scaling driver
 *
 * Copyright (C) 2019 Texas Instruments Incorporated - http://www.ti.com/
 *      Tero Kristo <[email protected]>
 *
 */

#include <common.h>
#include <dm.h>
#include <errno.h>
#include <asm/io.h>
#include <i2c.h>
#include <k3-avs.h>
#include <dm/device_compat.h>
#include <linux/bitops.h>
#include <power/regulator.h>

#define AM6_VTM_DEVINFO(i)	(priv->base + 0x100 + 0x20 * (i))
#define AM6_VTM_OPPVID_VD(i)	(priv->base + 0x104 + 0x20 * (i))

#define AM6_VTM_AVS0_SUPPORTED	BIT(12)

#define AM6_VTM_OPP_SHIFT(opp)	(8 * (opp))
#define AM6_VTM_OPP_MASK	0xff

#define VD_FLAG_INIT_DONE	BIT(0)

struct k3_avs_privdata {
	void *base;
	struct vd_config *vd_config;
};

struct opp {
	u32 freq;
	u32 volt;
};

struct vd_data {
	int id;
	u8 opp;
	u8 flags;
	int dev_id;
	int clk_id;
	struct opp opps[NUM_OPPS];
	struct udevice *supply;
};

struct vd_config {
	struct vd_data *vds;
	u32 (*efuse_xlate)(struct k3_avs_privdata *priv, int idx, int opp);
};

static struct k3_avs_privdata *k3_avs_priv;

/**
 * am6_efuse_voltage: read efuse voltage from VTM
 * @priv: driver private data
 * @idx: VD to read efuse for
 * @opp: opp id to read
 *
 * Reads efuse value for the specified OPP, and converts the register
 * value to a voltage. Returns the voltage in uV, or 0 if nominal voltage
 * should be used.
 *
 * Efuse val to volt conversion logic:
 *
 * val > 171 volt increments in 20mV steps with base 171 => 1.66V
 * val between 115 to 11 increments in 10mV steps with base 115 => 1.1V
 * val between 15 to 115 increments in 5mV steps with base 15 => .6V
 * val between 1 to 15 increments in 20mv steps with base 0 => .3V
 * val 0 is invalid
 */
static u32 am6_efuse_xlate(struct k3_avs_privdata *priv, int idx, int opp)
{
	u32 val = readl(AM6_VTM_OPPVID_VD(idx));

	val >>= AM6_VTM_OPP_SHIFT(opp);
	val &= AM6_VTM_OPP_MASK;

	if (!val)
		return 0;

	if (val > 171)
		return 1660000 + 20000 * (val - 171);

	if (val > 115)
		return 1100000 + 10000 * (val - 115);

	if (val > 15)
		return 600000 + 5000 * (val - 15);

	return 300000 + 20000 * val;
}

static int k3_avs_program_voltage(struct k3_avs_privdata *priv,
				  struct vd_data *vd,
				  int opp_id)
{
	u32 volt = vd->opps[opp_id].volt;
	struct vd_data *vd2;

	if (!vd->supply)
		return -ENODEV;

	vd->opp = opp_id;
	vd->flags |= VD_FLAG_INIT_DONE;

	/* Take care of ganged rails and pick the Max amongst them*/
	for (vd2 = priv->vd_config->vds; vd2->id >= 0; vd2++) {
		if (vd == vd2)
			continue;

		if (vd2->supply != vd->supply)
			continue;

		if (vd2->opps[vd2->opp].volt > volt)
			volt = vd2->opps[vd2->opp].volt;

		vd2->flags |= VD_FLAG_INIT_DONE;
	}

	return regulator_set_value(vd->supply, volt);
}

static struct vd_data *get_vd(struct k3_avs_privdata *priv, int idx)
{
	struct vd_data *vd;

	for (vd = priv->vd_config->vds; vd->id >= 0 && vd->id != idx; vd++)
		;

	if (vd->id < 0)
		return NULL;

	return vd;
}

/**
 * k3_avs_set_opp: Sets the voltage for an arbitrary VD rail
 * @dev: AVS device
 * @vdd_id: voltage domain ID
 * @opp_id: OPP ID
 *
 * Programs the desired OPP value for the defined voltage rail. This
 * should be called from board files if reconfiguration is desired.
 * Returns 0 on success, negative error value on failure.
 */
int k3_avs_set_opp(struct udevice *dev, int vdd_id, int opp_id)
{
	struct k3_avs_privdata *priv = dev_get_priv(dev);
	struct vd_data *vd;

	vd = get_vd(priv, vdd_id);
	if (!vd)
		return -EINVAL;

	return k3_avs_program_voltage(priv, vd, opp_id);
}

static int match_opp(struct vd_data *vd, u32 freq)
{
	struct opp *opp;
	int opp_id;

	for (opp_id = 0; opp_id < NUM_OPPS; opp_id++) {
		opp = &vd->opps[opp_id];
		if (opp->freq == freq)
			return opp_id;
	}

	printf("No matching OPP found for freq %d.\n", freq);

	return -EINVAL;
}

/**
 * k3_avs_notify_freq: Notify clock rate change towards AVS subsystem
 * @dev_id: Device ID for the clock to be changed
 * @clk_id: Clock ID for the clock to be changed
 * @freq: New frequency for clock
 *
 * Checks if the provided clock is the MPU clock or not, if not, return
 * immediately. If MPU clock is provided, maps the provided MPU frequency
 * towards an MPU OPP, and programs the voltage to the regulator. Return 0
 * on success, negative error value on failure.
 */
int k3_avs_notify_freq(int dev_id, int clk_id, u32 freq)
{
	int opp_id;
	struct k3_avs_privdata *priv = k3_avs_priv;
	struct vd_data *vd;

	/* Driver may not be probed yet */
	if (!priv)
		return -EINVAL;

	for (vd = priv->vd_config->vds; vd->id >= 0; vd++) {
		if (vd->dev_id != dev_id || vd->clk_id != clk_id)
			continue;

		opp_id = match_opp(vd, freq);
		if (opp_id < 0)
			return opp_id;

		vd->opp = opp_id;
		return k3_avs_program_voltage(priv, vd, opp_id);
	}

	return -EINVAL;
}

static int k3_avs_configure(struct udevice *dev, struct k3_avs_privdata *priv)
{
	struct vd_config *conf;
	int ret;
	char pname[20];
	struct vd_data *vd;

	conf = (void *)dev_get_driver_data(dev);

	priv->vd_config = conf;

	for (vd = conf->vds; vd->id >= 0; vd++) {
		sprintf(pname, "vdd-supply-%d", vd->id);
		ret = device_get_supply_regulator(dev, pname, &vd->supply);
		if (ret)
			dev_warn(dev, "supply not found for VD%d.\n", vd->id);

		sprintf(pname, "ti,default-opp-%d", vd->id);
		ret = dev_read_u32_default(dev, pname, -1);
		if (ret != -1)
			vd->opp = ret;
	}

	return 0;
}

/**
 * k3_avs_probe: parses VD info from VTM, and re-configures the OPP data
 *
 * Parses all VDs on a device calculating the AVS class-0 voltages for them,
 * and updates the vd_data based on this. The vd_data itself shall be used
 * to program the required OPPs later on. Returns 0 on success, negative
 * error value on failure.
 */
static int k3_avs_probe(struct udevice *dev)
{
	int opp_id;
	u32 volt;
	struct opp *opp;
	struct k3_avs_privdata *priv;
	struct vd_data *vd;
	int ret;

	priv = dev_get_priv(dev);

	k3_avs_priv = priv;

	ret = k3_avs_configure(dev, priv);
	if (ret)
		return ret;

	priv->base = dev_read_addr_ptr(dev);
	if (!priv->base)
		return -ENODEV;

	for (vd = priv->vd_config->vds; vd->id >= 0; vd++) {
		if (!(readl(AM6_VTM_DEVINFO(vd->id)) &
		      AM6_VTM_AVS0_SUPPORTED)) {
			dev_warn(dev, "AVS-class 0 not supported for VD%d\n",
				 vd->id);
			continue;
		}

		for (opp_id = 0; opp_id < NUM_OPPS; opp_id++) {
			opp = &vd->opps[opp_id];

			if (!opp->freq)
				continue;

			volt = priv->vd_config->efuse_xlate(priv, vd->id,
							    opp_id);
			if (volt)
				opp->volt = volt;
		}
	}

	for (vd = priv->vd_config->vds; vd->id >= 0; vd++) {
		if (vd->flags & VD_FLAG_INIT_DONE)
			continue;

		k3_avs_program_voltage(priv, vd, vd->opp);
	}

	return 0;
}

static struct vd_data am654_vd_data[] = {
	{
		.id = AM6_VDD_CORE,
		.dev_id = 82, /* AM6_DEV_CBASS0 */
		.clk_id = 0, /* main sysclk0 */
		.opp = AM6_OPP_NOM,
		.opps = {
			[AM6_OPP_NOM] = {
				.volt = 1000000,
				.freq = 250000000, /* CBASS0 */
			},
		},
	},
	{
		.id = AM6_VDD_MPU0,
		.dev_id = 202, /* AM6_DEV_COMPUTE_CLUSTER_A53_0 */
		.clk_id = 0, /* ARM clock */
		.opp = AM6_OPP_NOM,
		.opps = {
			[AM6_OPP_NOM] = {
				.volt = 1100000,
				.freq = 800000000,
			},
			[AM6_OPP_OD] = {
				.volt = 1200000,
				.freq = 1000000000,
			},
			[AM6_OPP_TURBO] = {
				.volt = 1240000,
				.freq = 1100000000,
			},
		},
	},
	{
		.id = AM6_VDD_MPU1,
		.opp = AM6_OPP_NOM,
		.dev_id = 204, /* AM6_DEV_COMPUTE_CLUSTER_A53_2 */
		.clk_id = 0, /* ARM clock */
		.opps = {
			[AM6_OPP_NOM] = {
				.volt = 1100000,
				.freq = 800000000,
			},
			[AM6_OPP_OD] = {
				.volt = 1200000,
				.freq = 1000000000,
			},
			[AM6_OPP_TURBO] = {
				.volt = 1240000,
				.freq = 1100000000,
			},
		},
	},
	{ .id = -1 },
};

static struct vd_data j721e_vd_data[] = {
	{
		.id = J721E_VDD_MPU,
		.opp = AM6_OPP_NOM,
		.dev_id = 202, /* J721E_DEV_A72SS0_CORE0 */
		.clk_id = 2, /* ARM clock */
		.opps = {
			[AM6_OPP_NOM] = {
				.volt = 880000, /* TBD in DM */
				.freq = 2000000000,
			},
		},
	},
	{ .id = -1 },
};

static struct vd_config j721e_vd_config = {
	.efuse_xlate = am6_efuse_xlate,
	.vds = j721e_vd_data,
};

static struct vd_config am654_vd_config = {
	.efuse_xlate = am6_efuse_xlate,
	.vds = am654_vd_data,
};

static const struct udevice_id k3_avs_ids[] = {
	{ .compatible = "ti,am654-avs", .data = (ulong)&am654_vd_config },
	{ .compatible = "ti,j721e-avs", .data = (ulong)&j721e_vd_config },
	{}
};

U_BOOT_DRIVER(k3_avs) = {
	.name = "k3_avs",
	.of_match = k3_avs_ids,
	.id = UCLASS_MISC,
	.probe = k3_avs_probe,
	.priv_auto	= sizeof(struct k3_avs_privdata),
};
Commit	Line	Data
9d233b4e TK	1	// SPDX-License-Identifier: GPL-2.0+
	2	/*
	3	* Texas Instruments' K3 Clas 0 Adaptive Voltage Scaling driver
	4	*
	5	* Copyright (C) 2019 Texas Instruments Incorporated - http://www.ti.com/
	6	* Tero Kristo <[email protected]>
	7	*
	8	*/
	9
	10	#include <common.h>
	11	#include <dm.h>
	12	#include <errno.h>
	13	#include <asm/io.h>
	14	#include <i2c.h>
	15	#include <k3-avs.h>
336d4615	16	#include <dm/device_compat.h>
cd93d625	17	#include <linux/bitops.h>
9d233b4e TK	18	#include <power/regulator.h>
	19
	20	#define AM6_VTM_DEVINFO(i) (priv->base + 0x100 + 0x20 * (i))
	21	#define AM6_VTM_OPPVID_VD(i) (priv->base + 0x104 + 0x20 * (i))
	22
	23	#define AM6_VTM_AVS0_SUPPORTED BIT(12)
	24
	25	#define AM6_VTM_OPP_SHIFT(opp) (8 * (opp))
	26	#define AM6_VTM_OPP_MASK 0xff
	27
	28	#define VD_FLAG_INIT_DONE BIT(0)
	29
	30	struct k3_avs_privdata {
	31	void *base;
	32	struct vd_config *vd_config;
	33	};
	34
	35	struct opp {
	36	u32 freq;
	37	u32 volt;
	38	};
	39
	40	struct vd_data {
	41	int id;
	42	u8 opp;
	43	u8 flags;
	44	int dev_id;
	45	int clk_id;
	46	struct opp opps[NUM_OPPS];
	47	struct udevice *supply;
	48	};
	49
	50	struct vd_config {
	51	struct vd_data *vds;
	52	u32 (efuse_xlate)(struct k3_avs_privdata priv, int idx, int opp);
	53	};
	54
	55	static struct k3_avs_privdata *k3_avs_priv;
	56
	57	/**
	58	* am6_efuse_voltage: read efuse voltage from VTM
	59	* @priv: driver private data
	60	* @idx: VD to read efuse for
	61	* @opp: opp id to read
	62	*
	63	* Reads efuse value for the specified OPP, and converts the register
	64	* value to a voltage. Returns the voltage in uV, or 0 if nominal voltage
	65	* should be used.
	66	*
	67	* Efuse val to volt conversion logic:
	68	*
	69	* val > 171 volt increments in 20mV steps with base 171 => 1.66V
	70	* val between 115 to 11 increments in 10mV steps with base 115 => 1.1V
	71	* val between 15 to 115 increments in 5mV steps with base 15 => .6V
	72	* val between 1 to 15 increments in 20mv steps with base 0 => .3V
	73	* val 0 is invalid
	74	*/
	75	static u32 am6_efuse_xlate(struct k3_avs_privdata *priv, int idx, int opp)
	76	{
	77	u32 val = readl(AM6_VTM_OPPVID_VD(idx));
	78
	79	val >>= AM6_VTM_OPP_SHIFT(opp);
	80	val &= AM6_VTM_OPP_MASK;
	81
82	if (!val)
83	return 0;
84
85	if (val > 171)
86	return 1660000 + 20000 * (val - 171);
87
88	if (val > 115)
89	return 1100000 + 10000 * (val - 115);
90
91	if (val > 15)
92	return 600000 + 5000 * (val - 15);
93
94	return 300000 + 20000 * val;
95	}
96
97	static int k3_avs_program_voltage(struct k3_avs_privdata *priv,
98	struct vd_data *vd,
99	int opp_id)
100	{
101	u32 volt = vd->opps[opp_id].volt;
102	struct vd_data *vd2;
103
104	if (!vd->supply)
105	return -ENODEV;
106
107	vd->opp = opp_id;
108	vd->flags \|= VD_FLAG_INIT_DONE;
109
110	/* Take care of ganged rails and pick the Max amongst them*/
111	for (vd2 = priv->vd_config->vds; vd2->id >= 0; vd2++) {
112	if (vd == vd2)
113	continue;
114
115	if (vd2->supply != vd->supply)
116	continue;
117
118	if (vd2->opps[vd2->opp].volt > volt)
119	volt = vd2->opps[vd2->opp].volt;
120
121	vd2->flags \|= VD_FLAG_INIT_DONE;
122	}
123
124	return regulator_set_value(vd->supply, volt);
125	}
126
127	static struct vd_data get_vd(struct k3_avs_privdata priv, int idx)
128	{
129	struct vd_data *vd;
130
131	for (vd = priv->vd_config->vds; vd->id >= 0 && vd->id != idx; vd++)
132	;
133
134	if (vd->id < 0)
135	return NULL;
136
137	return vd;
138	}
139
140	/**
141	* k3_avs_set_opp: Sets the voltage for an arbitrary VD rail
142	* @dev: AVS device
143	* @vdd_id: voltage domain ID
144	* @opp_id: OPP ID
145	*
146	* Programs the desired OPP value for the defined voltage rail. This
147	* should be called from board files if reconfiguration is desired.
148	* Returns 0 on success, negative error value on failure.
149	*/
150	int k3_avs_set_opp(struct udevice *dev, int vdd_id, int opp_id)
151	{
152	struct k3_avs_privdata *priv = dev_get_priv(dev);
153	struct vd_data *vd;
154
155	vd = get_vd(priv, vdd_id);
156	if (!vd)
157	return -EINVAL;
158
159	return k3_avs_program_voltage(priv, vd, opp_id);
160	}
161
162	static int match_opp(struct vd_data *vd, u32 freq)
163	{
164	struct opp *opp;
165	int opp_id;
166
167	for (opp_id = 0; opp_id < NUM_OPPS; opp_id++) {
168	opp = &vd->opps[opp_id];
169	if (opp->freq == freq)
170	return opp_id;
171	}
172
173	printf("No matching OPP found for freq %d.\n", freq);
174
175	return -EINVAL;
176	}
177
178	/**
179	* k3_avs_notify_freq: Notify clock rate change towards AVS subsystem
180	* @dev_id: Device ID for the clock to be changed
181	* @clk_id: Clock ID for the clock to be changed
182	* @freq: New frequency for clock
183	*
184	* Checks if the provided clock is the MPU clock or not, if not, return
185	* immediately. If MPU clock is provided, maps the provided MPU frequency
186	* towards an MPU OPP, and programs the voltage to the regulator. Return 0
187	* on success, negative error value on failure.
188	*/
189	int k3_avs_notify_freq(int dev_id, int clk_id, u32 freq)
190	{
191	int opp_id;
192	struct k3_avs_privdata *priv = k3_avs_priv;
193	struct vd_data *vd;
194
7a8d03f8 VR	195	/* Driver may not be probed yet */
	196	if (!priv)
	197	return -EINVAL;
	198
9d233b4e TK	199	for (vd = priv->vd_config->vds; vd->id >= 0; vd++) {
	200	if (vd->dev_id != dev_id \|\| vd->clk_id != clk_id)
	201	continue;
	202
	203	opp_id = match_opp(vd, freq);
	204	if (opp_id < 0)
	205	return opp_id;
	206
	207	vd->opp = opp_id;
	208	return k3_avs_program_voltage(priv, vd, opp_id);
	209	}
	210
	211	return -EINVAL;
	212	}
	213
	214	static int k3_avs_configure(struct udevice dev, struct k3_avs_privdata priv)
	215	{
	216	struct vd_config *conf;
	217	int ret;
	218	char pname[20];
	219	struct vd_data *vd;
	220
	221	conf = (void *)dev_get_driver_data(dev);
	222
	223	priv->vd_config = conf;
	224
	225	for (vd = conf->vds; vd->id >= 0; vd++) {
	226	sprintf(pname, "vdd-supply-%d", vd->id);
	227	ret = device_get_supply_regulator(dev, pname, &vd->supply);
	228	if (ret)
	229	dev_warn(dev, "supply not found for VD%d.\n", vd->id);
	230
	231	sprintf(pname, "ti,default-opp-%d", vd->id);
	232	ret = dev_read_u32_default(dev, pname, -1);
	233	if (ret != -1)
	234	vd->opp = ret;
	235	}
	236
	237	return 0;
	238	}
	239
	240	/**
	241	* k3_avs_probe: parses VD info from VTM, and re-configures the OPP data
	242	*
	243	* Parses all VDs on a device calculating the AVS class-0 voltages for them,
	244	* and updates the vd_data based on this. The vd_data itself shall be used
	245	* to program the required OPPs later on. Returns 0 on success, negative
	246	* error value on failure.
	247	*/
	248	static int k3_avs_probe(struct udevice *dev)
	249	{
	250	int opp_id;
	251	u32 volt;
	252	struct opp *opp;
	253	struct k3_avs_privdata *priv;
	254	struct vd_data *vd;
	255	int ret;
	256
	257	priv = dev_get_priv(dev);
	258
	259	k3_avs_priv = priv;
	260
	261	ret = k3_avs_configure(dev, priv);
	262	if (ret)
263	return ret;
264
265	priv->base = dev_read_addr_ptr(dev);
266	if (!priv->base)
267	return -ENODEV;
268
269	for (vd = priv->vd_config->vds; vd->id >= 0; vd++) {
270	if (!(readl(AM6_VTM_DEVINFO(vd->id)) &
271	AM6_VTM_AVS0_SUPPORTED)) {
272	dev_warn(dev, "AVS-class 0 not supported for VD%d\n",
273	vd->id);
274	continue;
275	}
276
277	for (opp_id = 0; opp_id < NUM_OPPS; opp_id++) {
278	opp = &vd->opps[opp_id];
279
280	if (!opp->freq)
281	continue;
282
283	volt = priv->vd_config->efuse_xlate(priv, vd->id,
284	opp_id);
285	if (volt)
286	opp->volt = volt;
287	}
288	}
289
290	for (vd = priv->vd_config->vds; vd->id >= 0; vd++) {
291	if (vd->flags & VD_FLAG_INIT_DONE)
292	continue;
293
294	k3_avs_program_voltage(priv, vd, vd->opp);
295	}
296
297	return 0;
298	}
299
300	static struct vd_data am654_vd_data[] = {
301	{
302	.id = AM6_VDD_CORE,
303	.dev_id = 82, /* AM6_DEV_CBASS0 */
304	.clk_id = 0, /* main sysclk0 */
305	.opp = AM6_OPP_NOM,
306	.opps = {
307	[AM6_OPP_NOM] = {
308	.volt = 1000000,
309	.freq = 250000000, /* CBASS0 */
310	},
311	},
312	},
313	{
314	.id = AM6_VDD_MPU0,
315	.dev_id = 202, /* AM6_DEV_COMPUTE_CLUSTER_A53_0 */
316	.clk_id = 0, /* ARM clock */
317	.opp = AM6_OPP_NOM,
318	.opps = {
319	[AM6_OPP_NOM] = {
3e7b0aa1	320	.volt = 1100000,
9d233b4e TK	321	.freq = 800000000,
	322	},
	323	[AM6_OPP_OD] = {
3e7b0aa1	324	.volt = 1200000,
9d233b4e TK	325	.freq = 1000000000,
	326	},
	327	[AM6_OPP_TURBO] = {
3e7b0aa1	328	.volt = 1240000,
9d233b4e TK	329	.freq = 1100000000,
	330	},
	331	},
	332	},
	333	{
	334	.id = AM6_VDD_MPU1,
	335	.opp = AM6_OPP_NOM,
	336	.dev_id = 204, /* AM6_DEV_COMPUTE_CLUSTER_A53_2 */
	337	.clk_id = 0, /* ARM clock */
	338	.opps = {
	339	[AM6_OPP_NOM] = {
3e7b0aa1	340	.volt = 1100000,
9d233b4e TK	341	.freq = 800000000,
	342	},
	343	[AM6_OPP_OD] = {
3e7b0aa1	344	.volt = 1200000,
9d233b4e TK	345	.freq = 1000000000,
	346	},
	347	[AM6_OPP_TURBO] = {
3e7b0aa1	348	.volt = 1240000,
9d233b4e TK	349	.freq = 1100000000,
	350	},
	351	},
	352	},
	353	{ .id = -1 },
	354	};
	355
9a03e50c K	356	static struct vd_data j721e_vd_data[] = {
	357	{
	358	.id = J721E_VDD_MPU,
	359	.opp = AM6_OPP_NOM,
	360	.dev_id = 202, /* J721E_DEV_A72SS0_CORE0 */
	361	.clk_id = 2, /* ARM clock */
	362	.opps = {
	363	[AM6_OPP_NOM] = {
	364	.volt = 880000, /* TBD in DM */
	365	.freq = 2000000000,
	366	},
	367	},
	368	},
	369	{ .id = -1 },
	370	};
	371
	372	static struct vd_config j721e_vd_config = {
	373	.efuse_xlate = am6_efuse_xlate,
	374	.vds = j721e_vd_data,
	375	};
	376
9d233b4e TK	377	static struct vd_config am654_vd_config = {
	378	.efuse_xlate = am6_efuse_xlate,
	379	.vds = am654_vd_data,
	380	};
	381
	382	static const struct udevice_id k3_avs_ids[] = {
	383	{ .compatible = "ti,am654-avs", .data = (ulong)&am654_vd_config },
9a03e50c	384	{ .compatible = "ti,j721e-avs", .data = (ulong)&j721e_vd_config },
9d233b4e TK	385	{}
	386	};
	387
	388	U_BOOT_DRIVER(k3_avs) = {
	389	.name = "k3_avs",
	390	.of_match = k3_avs_ids,
	391	.id = UCLASS_MISC,
	392	.probe = k3_avs_probe,
41575d8e	393	.priv_auto = sizeof(struct k3_avs_privdata),
9d233b4e	394	};