Commit a45f1d43 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'regmap-v5.11' of git://git.kernel.org/pub/scm/linux/kernel/git/broonie/regmap 

Pull regmap updates from Mark Brown:
 "This is quite a busy release for regmap with two substantial features
  being added:

    - Support for register maps Soundwire 1.2 multi-byte operations,
      allowing atomic support for registers larger than a single byte.

    - Support for relaxed I/O without barriers in MMIO regmaps, allowing
      them to be used efficiently on systems where default MMIO
      operations include barriers.

  There was also an addition and revert of use of the new Soundwire
  support for RT715 due to build issues with the driver built in, my
  tests only covered building it as a module, the patch wasn't just
  dropped as it had already been merged elsewhere"

* tag 'regmap-v5.11' of git://git.kernel.org/pub/scm/linux/kernel/git/broonie/regmap:
  ASoC: rt715: Fix build
  regmap: sdw: add required header files
  regmap: Remove duplicate `type` field from regmap `regcache_sync` trace event
  regmap: Fix order of regmap write log
  regmap: mmio: add config option to allow relaxed MMIO accesses
parents 2cffa11e 4616c509

drivers/base/regmap/regmap-mmio.c

+82 −8
Original line number Diff line number Diff line
@@ -16,6 +16,7 @@ 
struct regmap_mmio_context {

	void __iomem *regs;

	unsigned val_bytes;

	bool relaxed_mmio;



	bool attached_clk;

	struct clk *clk;
@@ -75,6 +76,13 @@ static void regmap_mmio_write8(struct regmap_mmio_context *ctx, 
	writeb(val, ctx->regs + reg);

}



static void regmap_mmio_write8_relaxed(struct regmap_mmio_context *ctx,

				unsigned int reg,

				unsigned int val)

{

	writeb_relaxed(val, ctx->regs + reg);

}



static void regmap_mmio_write16le(struct regmap_mmio_context *ctx,

				  unsigned int reg,

				  unsigned int val)
@@ -82,6 +90,13 @@ static void regmap_mmio_write16le(struct regmap_mmio_context *ctx, 
	writew(val, ctx->regs + reg);

}



static void regmap_mmio_write16le_relaxed(struct regmap_mmio_context *ctx,

				  unsigned int reg,

				  unsigned int val)

{

	writew_relaxed(val, ctx->regs + reg);

}



static void regmap_mmio_write16be(struct regmap_mmio_context *ctx,

				  unsigned int reg,

				  unsigned int val)
@@ -96,6 +111,13 @@ static void regmap_mmio_write32le(struct regmap_mmio_context *ctx, 
	writel(val, ctx->regs + reg);

}



static void regmap_mmio_write32le_relaxed(struct regmap_mmio_context *ctx,

				  unsigned int reg,

				  unsigned int val)

{

	writel_relaxed(val, ctx->regs + reg);

}



static void regmap_mmio_write32be(struct regmap_mmio_context *ctx,

				  unsigned int reg,

				  unsigned int val)
@@ -110,6 +132,13 @@ static void regmap_mmio_write64le(struct regmap_mmio_context *ctx, 
{

	writeq(val, ctx->regs + reg);

}



static void regmap_mmio_write64le_relaxed(struct regmap_mmio_context *ctx,

				  unsigned int reg,

				  unsigned int val)

{

	writeq_relaxed(val, ctx->regs + reg);

}

#endif



static int regmap_mmio_write(void *context, unsigned int reg, unsigned int val)
@@ -137,12 +166,24 @@ static unsigned int regmap_mmio_read8(struct regmap_mmio_context *ctx, 
	return readb(ctx->regs + reg);

}



static unsigned int regmap_mmio_read8_relaxed(struct regmap_mmio_context *ctx,

				      unsigned int reg)

{

	return readb_relaxed(ctx->regs + reg);

}



static unsigned int regmap_mmio_read16le(struct regmap_mmio_context *ctx,

				         unsigned int reg)

{

	return readw(ctx->regs + reg);

}



static unsigned int regmap_mmio_read16le_relaxed(struct regmap_mmio_context *ctx,

						 unsigned int reg)

{

	return readw_relaxed(ctx->regs + reg);

}



static unsigned int regmap_mmio_read16be(struct regmap_mmio_context *ctx,

				         unsigned int reg)

{
@@ -155,6 +196,12 @@ static unsigned int regmap_mmio_read32le(struct regmap_mmio_context *ctx, 
	return readl(ctx->regs + reg);

}



static unsigned int regmap_mmio_read32le_relaxed(struct regmap_mmio_context *ctx,

						 unsigned int reg)

{

	return readl_relaxed(ctx->regs + reg);

}



static unsigned int regmap_mmio_read32be(struct regmap_mmio_context *ctx,

				         unsigned int reg)

{
@@ -167,6 +214,12 @@ static unsigned int regmap_mmio_read64le(struct regmap_mmio_context *ctx, 
{

	return readq(ctx->regs + reg);

}



static unsigned int regmap_mmio_read64le_relaxed(struct regmap_mmio_context *ctx,

						 unsigned int reg)

{

	return readq_relaxed(ctx->regs + reg);

}

#endif



static int regmap_mmio_read(void *context, unsigned int reg, unsigned int *val)
@@ -237,6 +290,7 @@ static struct regmap_mmio_context *regmap_mmio_gen_context(struct device *dev, 


	ctx->regs = regs;

	ctx->val_bytes = config->val_bits / 8;

	ctx->relaxed_mmio = config->use_relaxed_mmio;

	ctx->clk = ERR_PTR(-ENODEV);



	switch (regmap_get_val_endian(dev, &regmap_mmio, config)) {
@@ -247,21 +301,41 @@ static struct regmap_mmio_context *regmap_mmio_gen_context(struct device *dev, 
#endif

		switch (config->val_bits) {

		case 8:

			if (ctx->relaxed_mmio) {

				ctx->reg_read = regmap_mmio_read8_relaxed;

				ctx->reg_write = regmap_mmio_write8_relaxed;

			} else {

				ctx->reg_read = regmap_mmio_read8;

				ctx->reg_write = regmap_mmio_write8;

			}

			break;

		case 16:

			if (ctx->relaxed_mmio) {

				ctx->reg_read = regmap_mmio_read16le_relaxed;

				ctx->reg_write = regmap_mmio_write16le_relaxed;

			} else {

				ctx->reg_read = regmap_mmio_read16le;

				ctx->reg_write = regmap_mmio_write16le;

			}

			break;

		case 32:

			if (ctx->relaxed_mmio) {

				ctx->reg_read = regmap_mmio_read32le_relaxed;

				ctx->reg_write = regmap_mmio_write32le_relaxed;

			} else {

				ctx->reg_read = regmap_mmio_read32le;

				ctx->reg_write = regmap_mmio_write32le;

			}

			break;

#ifdef CONFIG_64BIT

		case 64:

			if (ctx->relaxed_mmio) {

				ctx->reg_read = regmap_mmio_read64le_relaxed;

				ctx->reg_write = regmap_mmio_write64le_relaxed;

			} else {

				ctx->reg_read = regmap_mmio_read64le;

				ctx->reg_write = regmap_mmio_write64le;

			}

			break;

#endif

		default:

drivers/base/regmap/regmap-sdw.c

+2 −0
Original line number Diff line number Diff line
@@ -2,7 +2,9 @@ 
// Copyright(c) 2015-17 Intel Corporation.



#include <linux/device.h>

#include <linux/errno.h>

#include <linux/module.h>

#include <linux/regmap.h>

#include <linux/soundwire/sdw.h>

#include "internal.h"

drivers/base/regmap/regmap.c

+7 −4
Original line number Diff line number Diff line
@@ -1924,12 +1924,15 @@ int _regmap_write(struct regmap *map, unsigned int reg, 
		}

	}



	ret = map->reg_write(context, reg, val);

	if (ret == 0) {

		if (regmap_should_log(map))

			dev_info(map->dev, "%x <= %x\n", reg, val);



		trace_regmap_reg_write(map, reg, val);

	}



	return map->reg_write(context, reg, val);

	return ret;

}



/**

drivers/base/regmap/trace.h

+0 −1
Original line number Diff line number Diff line
@@ -126,7 +126,6 @@ TRACE_EVENT(regcache_sync, 
		__string(       name,           regmap_name(map)	)

		__string(	status,		status			)

		__string(	type,		type			)

		__field(	int,		type			)

	),



	TP_fast_assign(

include/linux/regmap.h

+5 −0
Original line number Diff line number Diff line
@@ -315,6 +315,10 @@ typedef void (*regmap_unlock)(void *); 
 *                   masks are used.

 * @zero_flag_mask: If set, read_flag_mask and write_flag_mask are used even

 *                   if they are both empty.

 * @use_relaxed_mmio: If set, MMIO R/W operations will not use memory barriers.

 *                    This can avoid load on devices which don't require strict

 *                    orderings, but drivers should carefully add any explicit

 *                    memory barriers when they may require them.

 * @use_single_read: If set, converts the bulk read operation into a series of

 *                   single read operations. This is useful for a device that

 *                   does not support  bulk read.
@@ -388,6 +392,7 @@ struct regmap_config { 


	bool use_single_read;

	bool use_single_write;

	bool use_relaxed_mmio;

	bool can_multi_write;



	enum regmap_endian reg_format_endian;

CRA Git | Maintained and supported by SUSTech CRA and CCSE