regmap-sdw-mbq.c

  1// SPDX-License-Identifier: GPL-2.0
  2// Copyright(c) 2020 Intel Corporation.
  3
  4#include <linux/bits.h>
  5#include <linux/delay.h>
  6#include <linux/device.h>
  7#include <linux/errno.h>
  8#include <linux/iopoll.h>
  9#include <linux/module.h>
 10#include <linux/regmap.h>
 11#include <linux/soundwire/sdw.h>
 12#include <linux/soundwire/sdw_registers.h>
 13#include <sound/sdca_function.h>
 14#include "internal.h"
 15
 16struct regmap_mbq_context {
 17	struct device *dev;
 18	struct sdw_slave *sdw;
 19
 20	bool (*readable_reg)(struct device *dev, unsigned int reg);
 21
 22	struct regmap_sdw_mbq_cfg cfg;
 23
 24	int val_size;
 25};
 26
 27static int regmap_sdw_mbq_size(struct regmap_mbq_context *ctx, unsigned int reg)
 28{
 29	int size = ctx->val_size;
 30
 31	if (ctx->cfg.mbq_size) {
 32		size = ctx->cfg.mbq_size(ctx->dev, reg);
 33		if (!size || size > ctx->val_size)
 34			return -EINVAL;
 35	}
 36
 37	return size;
 38}
 39
 40static bool regmap_sdw_mbq_deferrable(struct regmap_mbq_context *ctx, unsigned int reg)
 41{
 42	if (ctx->cfg.deferrable)
 43		return ctx->cfg.deferrable(ctx->dev, reg);
 44
 45	return false;
 46}
 47
 48static int regmap_sdw_mbq_poll_busy(struct sdw_slave *slave, unsigned int reg,
 49				    struct regmap_mbq_context *ctx)
 50{
 51	struct device *dev = ctx->dev;
 52	int val, ret = 0;
 53
 54	dev_dbg(dev, "Deferring transaction for 0x%x\n", reg);
 55
 56	reg = SDW_SDCA_CTL(SDW_SDCA_CTL_FUNC(reg), 0,
 57			   SDCA_CTL_ENTITY_0_FUNCTION_STATUS, 0);
 58
 59	if (ctx->readable_reg(dev, reg)) {
 60		ret = read_poll_timeout(sdw_read_no_pm, val,
 61					val < 0 || !(val & SDCA_CTL_ENTITY_0_FUNCTION_BUSY),
 62					ctx->cfg.timeout_us, ctx->cfg.retry_us,
 63					false, slave, reg);
 64		if (val < 0)
 65			return val;
 66		if (ret)
 67			dev_err(dev, "Function busy timed out 0x%x: %d\n", reg, val);
 68	} else {
 69		fsleep(ctx->cfg.timeout_us);
 70	}
 71
 72	return ret;
 73}
 74
 75static int regmap_sdw_mbq_write_impl(struct sdw_slave *slave,
 76				     unsigned int reg, unsigned int val,
 77				     int mbq_size, bool deferrable)
 78{
 79	int shift = mbq_size * BITS_PER_BYTE;
 80	int ret;
 81
 82	while (--mbq_size > 0) {
 83		shift -= BITS_PER_BYTE;
 84
 85		ret = sdw_write_no_pm(slave, SDW_SDCA_MBQ_CTL(reg),
 86				      (val >> shift) & 0xff);
 87		if (ret < 0)
 88			return ret;
 89	}
 90
 91	ret = sdw_write_no_pm(slave, reg, val & 0xff);
 92	if (deferrable && ret == -ENODATA)
 93		return -EAGAIN;
 94
 95	return ret;
 96}
 97
 98static int regmap_sdw_mbq_write(void *context, unsigned int reg, unsigned int val)
 99{
100	struct regmap_mbq_context *ctx = context;
101	struct sdw_slave *slave = ctx->sdw;
102	bool deferrable = regmap_sdw_mbq_deferrable(ctx, reg);
103	int mbq_size = regmap_sdw_mbq_size(ctx, reg);
104	int ret;
105
106	if (mbq_size < 0)
107		return mbq_size;
108
109	/*
110	 * Technically the spec does allow a device to set itself to busy for
111	 * internal reasons, but since it doesn't provide any information on
112	 * how to handle timeouts in that case, for now the code will only
113	 * process a single wait/timeout on function busy and a single retry
114	 * of the transaction.
115	 */
116	ret = regmap_sdw_mbq_write_impl(slave, reg, val, mbq_size, deferrable);
117	if (ret == -EAGAIN) {
118		ret = regmap_sdw_mbq_poll_busy(slave, reg, ctx);
119		if (ret)
120			return ret;
121
122		ret = regmap_sdw_mbq_write_impl(slave, reg, val, mbq_size, false);
123	}
124
125	return ret;
126}
127
128static int regmap_sdw_mbq_read_impl(struct sdw_slave *slave,
129				    unsigned int reg, unsigned int *val,
130				    int mbq_size, bool deferrable)
131{
132	int shift = BITS_PER_BYTE;
133	int read;
134
135	read = sdw_read_no_pm(slave, reg);
136	if (read < 0) {
137		if (deferrable && read == -ENODATA)
138			return -EAGAIN;
139
140		return read;
141	}
142
143	*val = read;
144
145	while (--mbq_size > 0) {
146		read = sdw_read_no_pm(slave, SDW_SDCA_MBQ_CTL(reg));
147		if (read < 0)
148			return read;
149
150		*val |= read << shift;
151		shift += BITS_PER_BYTE;
152	}
153
154	return 0;
155}
156
157static int regmap_sdw_mbq_read(void *context, unsigned int reg, unsigned int *val)
158{
159	struct regmap_mbq_context *ctx = context;
160	struct sdw_slave *slave = ctx->sdw;
161	bool deferrable = regmap_sdw_mbq_deferrable(ctx, reg);
162	int mbq_size = regmap_sdw_mbq_size(ctx, reg);
163	int ret;
164
165	if (mbq_size < 0)
166		return mbq_size;
167
168	/*
169	 * Technically the spec does allow a device to set itself to busy for
170	 * internal reasons, but since it doesn't provide any information on
171	 * how to handle timeouts in that case, for now the code will only
172	 * process a single wait/timeout on function busy and a single retry
173	 * of the transaction.
174	 */
175	ret = regmap_sdw_mbq_read_impl(slave, reg, val, mbq_size, deferrable);
176	if (ret == -EAGAIN) {
177		ret = regmap_sdw_mbq_poll_busy(slave, reg, ctx);
178		if (ret)
179			return ret;
180
181		ret = regmap_sdw_mbq_read_impl(slave, reg, val, mbq_size, false);
182	}
183
184	return ret;
185}
186
187static const struct regmap_bus regmap_sdw_mbq = {
188	.reg_read = regmap_sdw_mbq_read,
189	.reg_write = regmap_sdw_mbq_write,
190	.reg_format_endian_default = REGMAP_ENDIAN_LITTLE,
191	.val_format_endian_default = REGMAP_ENDIAN_LITTLE,
192};
193
194static int regmap_sdw_mbq_config_check(const struct regmap_config *config)
195{
196	if (config->val_bits > (sizeof(unsigned int) * BITS_PER_BYTE))
197		return -ENOTSUPP;
198
199	/* Registers are 32 bits wide */
200	if (config->reg_bits != 32)
201		return -ENOTSUPP;
202
203	if (config->pad_bits != 0)
204		return -ENOTSUPP;
205
206	return 0;
207}
208
209static struct regmap_mbq_context *
210regmap_sdw_mbq_gen_context(struct device *dev,
211			   struct sdw_slave *sdw,
212			   const struct regmap_config *config,
213			   const struct regmap_sdw_mbq_cfg *mbq_config)
214{
215	struct regmap_mbq_context *ctx;
216
217	ctx = devm_kzalloc(dev, sizeof(*ctx), GFP_KERNEL);
218	if (!ctx)
219		return ERR_PTR(-ENOMEM);
220
221	ctx->dev = dev;
222	ctx->sdw = sdw;
223
224	if (mbq_config)
225		ctx->cfg = *mbq_config;
226
227	ctx->val_size = config->val_bits / BITS_PER_BYTE;
228	ctx->readable_reg = config->readable_reg;
229
230	return ctx;
231}
232
233struct regmap *__regmap_init_sdw_mbq(struct device *dev, struct sdw_slave *sdw,
234				     const struct regmap_config *config,
235				     const struct regmap_sdw_mbq_cfg *mbq_config,
236				     struct lock_class_key *lock_key,
237				     const char *lock_name)
238{
239	struct regmap_mbq_context *ctx;
240	int ret;
241
242	ret = regmap_sdw_mbq_config_check(config);
243	if (ret)
244		return ERR_PTR(ret);
245
246	ctx = regmap_sdw_mbq_gen_context(dev, sdw, config, mbq_config);
247	if (IS_ERR(ctx))
248		return ERR_CAST(ctx);
249
250	return __regmap_init(dev, &regmap_sdw_mbq, ctx,
251			     config, lock_key, lock_name);
252}
253EXPORT_SYMBOL_GPL(__regmap_init_sdw_mbq);
254
255struct regmap *__devm_regmap_init_sdw_mbq(struct device *dev, struct sdw_slave *sdw,
256					  const struct regmap_config *config,
257					  const struct regmap_sdw_mbq_cfg *mbq_config,
258					  struct lock_class_key *lock_key,
259					  const char *lock_name)
260{
261	struct regmap_mbq_context *ctx;
262	int ret;
263
264	ret = regmap_sdw_mbq_config_check(config);
265	if (ret)
266		return ERR_PTR(ret);
267
268	ctx = regmap_sdw_mbq_gen_context(dev, sdw, config, mbq_config);
269	if (IS_ERR(ctx))
270		return ERR_CAST(ctx);
271
272	return __devm_regmap_init(dev, &regmap_sdw_mbq, ctx,
273				  config, lock_key, lock_name);
274}
275EXPORT_SYMBOL_GPL(__devm_regmap_init_sdw_mbq);
276
277MODULE_DESCRIPTION("regmap SoundWire MBQ Module");
278MODULE_LICENSE("GPL");