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

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

Pull regmap updates from Mark Brown:
 "This is a much bigger change for regmap than is normal, the main
  things being the addition of some KUnit coverage and a maple tree
  based register cache which longer term is likely to replace the rbtree
  cache except possibly for very small register maps.

  While it's complete overkill for most applications the code for maple
  trees is there and there are some larger, sparser devices where the
  data structure is a better fit.

  The maple tree support is still a work in progress but already useful,
  there's some conversions of drivers ready to go after the merge
  window.

  Summary:

   - Support for shifting register addresses up as well as down, there's
     a use cases with memory mapped MDIO.

   - Refactoring of the type configuration in regmap-irq to allow access
     to driver data in the handler, needed by some GPIO devices.

   - Some initial KUnit coverage, the bulk of the driver facing API is
     covered but there's holes and things like the data marshalling for
     bytestream buses are just not covered in the slightest.

   - Removal of the compressed cache type, it had zero users and was
     getting in the way of KUnit.

   - Addition of a maple tree based register cache, there's more work to
     do but it's already useful for some devices with a flatter data
     structure than rbtree and getting to use all the optimisation work
     Liam is doing"

* tag 'regmap-v6.4' of git://git.kernel.org/pub/scm/linux/kernel/git/broonie/regmap:
  regmap: allow upshifting register addresses before performing operations
  regmap: Pass irq_drv_data as a parameter for set_type_config()
  regmap: Use mas_walk() instead of mas_find()
  regmap: Fix double unlock in the maple cache
  regmap: Add maple tree based register cache
  regmap: Factor out single value register syncing
  regmap: Add some basic kunit tests
  regmap: Add RAM backed register map
  regmap: Removed compressed cache support
  regmap: Support paging for buses with reg_read()/reg_write()
  regmap: Clarify error for unknown cache types
  regmap: Handle sparse caches in the default sync
  regmap: add a helper to translate the register address
  regmap: cache: Silence checkpatch warning
  regmap: cache: Return error in cache sync operations for REGCACHE_NONE
  regmap-irq: Place kernel doc of struct regmap_irq_chip in order
  regmap-irq: Add no_status support
  regmap: sdw: Remove 8-bit value size restriction
  regmap: sdw: Update misleading comment
parents 088e0c18 4a670ac3

drivers/base/regmap/Kconfig

+9 −4
Original line number Diff line number Diff line
@@ -9,10 +9,12 @@ config REGMAP 
	select MDIO_BUS if REGMAP_MDIO

	bool



config REGCACHE_COMPRESSED

	select LZO_COMPRESS

	select LZO_DECOMPRESS

	bool

config REGMAP_KUNIT

	tristate "KUnit tests for regmap"

	depends on KUNIT

	default KUNIT_ALL_TESTS

	select REGMAP

	select REGMAP_RAM



config REGMAP_AC97

	tristate
@@ -46,6 +48,9 @@ config REGMAP_MMIO 
config REGMAP_IRQ

	bool



config REGMAP_RAM

	tristate



config REGMAP_SOUNDWIRE

	tristate

	depends on SOUNDWIRE

drivers/base/regmap/Makefile

+3 −2
Original line number Diff line number Diff line
@@ -3,11 +3,12 @@ 
CFLAGS_regmap.o := -I$(src)



obj-$(CONFIG_REGMAP) += regmap.o regcache.o

obj-$(CONFIG_REGMAP) += regcache-rbtree.o regcache-flat.o

obj-$(CONFIG_REGCACHE_COMPRESSED) += regcache-lzo.o

obj-$(CONFIG_REGMAP) += regcache-rbtree.o regcache-flat.o regcache-maple.o

obj-$(CONFIG_DEBUG_FS) += regmap-debugfs.o

obj-$(CONFIG_REGMAP_KUNIT) += regmap-kunit.o

obj-$(CONFIG_REGMAP_AC97) += regmap-ac97.o

obj-$(CONFIG_REGMAP_I2C) += regmap-i2c.o

obj-$(CONFIG_REGMAP_RAM) += regmap-ram.o

obj-$(CONFIG_REGMAP_SLIMBUS) += regmap-slimbus.o

obj-$(CONFIG_REGMAP_SPI) += regmap-spi.o

obj-$(CONFIG_REGMAP_SPMI) += regmap-spmi.o

drivers/base/regmap/internal.h

+22 −2
Original line number Diff line number Diff line
@@ -31,8 +31,8 @@ struct regmap_format { 
	size_t buf_size;

	size_t reg_bytes;

	size_t pad_bytes;

	size_t reg_downshift;

	size_t val_bytes;

	s8 reg_shift;

	void (*format_write)(struct regmap *map,

			     unsigned int reg, unsigned int val);

	void (*format_reg)(void *buf, unsigned int reg, unsigned int shift);
@@ -270,6 +270,7 @@ unsigned int regcache_get_val(struct regmap *map, const void *base, 
bool regcache_set_val(struct regmap *map, void *base, unsigned int idx,

		      unsigned int val);

int regcache_lookup_reg(struct regmap *map, unsigned int reg);

int regcache_sync_val(struct regmap *map, unsigned int reg, unsigned int val);



int _regmap_raw_write(struct regmap *map, unsigned int reg,

		      const void *val, size_t val_len, bool noinc);
@@ -281,7 +282,7 @@ enum regmap_endian regmap_get_val_endian(struct device *dev, 
					 const struct regmap_config *config);



extern struct regcache_ops regcache_rbtree_ops;

extern struct regcache_ops regcache_lzo_ops;

extern struct regcache_ops regcache_maple_ops;

extern struct regcache_ops regcache_flat_ops;



static inline const char *regmap_name(const struct regmap *map)
@@ -307,4 +308,23 @@ static inline unsigned int regcache_get_index_by_order(const struct regmap *map, 
	return reg >> map->reg_stride_order;

}



struct regmap_ram_data {

	unsigned int *vals;  /* Allocatd by caller */

	bool *read;

	bool *written;

};



/*

 * Create a test register map with data stored in RAM, not intended

 * for practical use.

 */

struct regmap *__regmap_init_ram(const struct regmap_config *config,

				 struct regmap_ram_data *data,

				 struct lock_class_key *lock_key,

				 const char *lock_name);



#define regmap_init_ram(config, data)					\

	__regmap_lockdep_wrapper(__regmap_init_ram, #config, config, data)





#endif

drivers/base/regmap/regcache-lzo.c

deleted100644 → 0
+0 −368
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

//

// Register cache access API - LZO caching support

//

// Copyright 2011 Wolfson Microelectronics plc

//

// Author: Dimitris Papastamos <dp@opensource.wolfsonmicro.com>



#include <linux/device.h>

#include <linux/lzo.h>

#include <linux/slab.h>



#include "internal.h"



static int regcache_lzo_exit(struct regmap *map);



struct regcache_lzo_ctx {

	void *wmem;

	void *dst;

	const void *src;

	size_t src_len;

	size_t dst_len;

	size_t decompressed_size;

	unsigned long *sync_bmp;

	int sync_bmp_nbits;

};



#define LZO_BLOCK_NUM 8

static int regcache_lzo_block_count(struct regmap *map)

{

	return LZO_BLOCK_NUM;

}



static int regcache_lzo_prepare(struct regcache_lzo_ctx *lzo_ctx)

{

	lzo_ctx->wmem = kmalloc(LZO1X_MEM_COMPRESS, GFP_KERNEL);

	if (!lzo_ctx->wmem)

		return -ENOMEM;

	return 0;

}



static int regcache_lzo_compress(struct regcache_lzo_ctx *lzo_ctx)

{

	size_t compress_size;

	int ret;



	ret = lzo1x_1_compress(lzo_ctx->src, lzo_ctx->src_len,

			       lzo_ctx->dst, &compress_size, lzo_ctx->wmem);

	if (ret != LZO_E_OK || compress_size > lzo_ctx->dst_len)

		return -EINVAL;

	lzo_ctx->dst_len = compress_size;

	return 0;

}



static int regcache_lzo_decompress(struct regcache_lzo_ctx *lzo_ctx)

{

	size_t dst_len;

	int ret;



	dst_len = lzo_ctx->dst_len;

	ret = lzo1x_decompress_safe(lzo_ctx->src, lzo_ctx->src_len,

				    lzo_ctx->dst, &dst_len);

	if (ret != LZO_E_OK || dst_len != lzo_ctx->dst_len)

		return -EINVAL;

	return 0;

}



static int regcache_lzo_compress_cache_block(struct regmap *map,

		struct regcache_lzo_ctx *lzo_ctx)

{

	int ret;



	lzo_ctx->dst_len = lzo1x_worst_compress(PAGE_SIZE);

	lzo_ctx->dst = kmalloc(lzo_ctx->dst_len, GFP_KERNEL);

	if (!lzo_ctx->dst) {

		lzo_ctx->dst_len = 0;

		return -ENOMEM;

	}



	ret = regcache_lzo_compress(lzo_ctx);

	if (ret < 0)

		return ret;

	return 0;

}



static int regcache_lzo_decompress_cache_block(struct regmap *map,

		struct regcache_lzo_ctx *lzo_ctx)

{

	int ret;



	lzo_ctx->dst_len = lzo_ctx->decompressed_size;

	lzo_ctx->dst = kmalloc(lzo_ctx->dst_len, GFP_KERNEL);

	if (!lzo_ctx->dst) {

		lzo_ctx->dst_len = 0;

		return -ENOMEM;

	}



	ret = regcache_lzo_decompress(lzo_ctx);

	if (ret < 0)

		return ret;

	return 0;

}



static inline int regcache_lzo_get_blkindex(struct regmap *map,

					    unsigned int reg)

{

	return ((reg / map->reg_stride) * map->cache_word_size) /

		DIV_ROUND_UP(map->cache_size_raw,

			     regcache_lzo_block_count(map));

}



static inline int regcache_lzo_get_blkpos(struct regmap *map,

					  unsigned int reg)

{

	return (reg / map->reg_stride) %

		    (DIV_ROUND_UP(map->cache_size_raw,

				  regcache_lzo_block_count(map)) /

		     map->cache_word_size);

}



static inline int regcache_lzo_get_blksize(struct regmap *map)

{

	return DIV_ROUND_UP(map->cache_size_raw,

			    regcache_lzo_block_count(map));

}



static int regcache_lzo_init(struct regmap *map)

{

	struct regcache_lzo_ctx **lzo_blocks;

	size_t bmp_size;

	int ret, i, blksize, blkcount;

	const char *p, *end;

	unsigned long *sync_bmp;



	ret = 0;



	blkcount = regcache_lzo_block_count(map);

	map->cache = kcalloc(blkcount, sizeof(*lzo_blocks),

			     GFP_KERNEL);

	if (!map->cache)

		return -ENOMEM;

	lzo_blocks = map->cache;



	/*

	 * allocate a bitmap to be used when syncing the cache with

	 * the hardware.  Each time a register is modified, the corresponding

	 * bit is set in the bitmap, so we know that we have to sync

	 * that register.

	 */

	bmp_size = map->num_reg_defaults_raw;

	sync_bmp = bitmap_zalloc(bmp_size, GFP_KERNEL);

	if (!sync_bmp) {

		ret = -ENOMEM;

		goto err;

	}



	/* allocate the lzo blocks and initialize them */

	for (i = 0; i < blkcount; i++) {

		lzo_blocks[i] = kzalloc(sizeof **lzo_blocks,

					GFP_KERNEL);

		if (!lzo_blocks[i]) {

			bitmap_free(sync_bmp);

			ret = -ENOMEM;

			goto err;

		}

		lzo_blocks[i]->sync_bmp = sync_bmp;

		lzo_blocks[i]->sync_bmp_nbits = bmp_size;

		/* alloc the working space for the compressed block */

		ret = regcache_lzo_prepare(lzo_blocks[i]);

		if (ret < 0)

			goto err;

	}



	blksize = regcache_lzo_get_blksize(map);

	p = map->reg_defaults_raw;

	end = map->reg_defaults_raw + map->cache_size_raw;

	/* compress the register map and fill the lzo blocks */

	for (i = 0; i < blkcount; i++, p += blksize) {

		lzo_blocks[i]->src = p;

		if (p + blksize > end)

			lzo_blocks[i]->src_len = end - p;

		else

			lzo_blocks[i]->src_len = blksize;

		ret = regcache_lzo_compress_cache_block(map,

						       lzo_blocks[i]);

		if (ret < 0)

			goto err;

		lzo_blocks[i]->decompressed_size =

			lzo_blocks[i]->src_len;

	}



	return 0;

err:

	regcache_lzo_exit(map);

	return ret;

}



static int regcache_lzo_exit(struct regmap *map)

{

	struct regcache_lzo_ctx **lzo_blocks;

	int i, blkcount;



	lzo_blocks = map->cache;

	if (!lzo_blocks)

		return 0;



	blkcount = regcache_lzo_block_count(map);

	/*

	 * the pointer to the bitmap used for syncing the cache

	 * is shared amongst all lzo_blocks.  Ensure it is freed

	 * only once.

	 */

	if (lzo_blocks[0])

		bitmap_free(lzo_blocks[0]->sync_bmp);

	for (i = 0; i < blkcount; i++) {

		if (lzo_blocks[i]) {

			kfree(lzo_blocks[i]->wmem);

			kfree(lzo_blocks[i]->dst);

		}

		/* each lzo_block is a pointer returned by kmalloc or NULL */

		kfree(lzo_blocks[i]);

	}

	kfree(lzo_blocks);

	map->cache = NULL;

	return 0;

}



static int regcache_lzo_read(struct regmap *map,

			     unsigned int reg, unsigned int *value)

{

	struct regcache_lzo_ctx *lzo_block, **lzo_blocks;

	int ret, blkindex, blkpos;

	size_t tmp_dst_len;

	void *tmp_dst;



	/* index of the compressed lzo block */

	blkindex = regcache_lzo_get_blkindex(map, reg);

	/* register index within the decompressed block */

	blkpos = regcache_lzo_get_blkpos(map, reg);

	lzo_blocks = map->cache;

	lzo_block = lzo_blocks[blkindex];



	/* save the pointer and length of the compressed block */

	tmp_dst = lzo_block->dst;

	tmp_dst_len = lzo_block->dst_len;



	/* prepare the source to be the compressed block */

	lzo_block->src = lzo_block->dst;

	lzo_block->src_len = lzo_block->dst_len;



	/* decompress the block */

	ret = regcache_lzo_decompress_cache_block(map, lzo_block);

	if (ret >= 0)

		/* fetch the value from the cache */

		*value = regcache_get_val(map, lzo_block->dst, blkpos);



	kfree(lzo_block->dst);

	/* restore the pointer and length of the compressed block */

	lzo_block->dst = tmp_dst;

	lzo_block->dst_len = tmp_dst_len;



	return ret;

}



static int regcache_lzo_write(struct regmap *map,

			      unsigned int reg, unsigned int value)

{

	struct regcache_lzo_ctx *lzo_block, **lzo_blocks;

	int ret, blkindex, blkpos;

	size_t tmp_dst_len;

	void *tmp_dst;



	/* index of the compressed lzo block */

	blkindex = regcache_lzo_get_blkindex(map, reg);

	/* register index within the decompressed block */

	blkpos = regcache_lzo_get_blkpos(map, reg);

	lzo_blocks = map->cache;

	lzo_block = lzo_blocks[blkindex];



	/* save the pointer and length of the compressed block */

	tmp_dst = lzo_block->dst;

	tmp_dst_len = lzo_block->dst_len;



	/* prepare the source to be the compressed block */

	lzo_block->src = lzo_block->dst;

	lzo_block->src_len = lzo_block->dst_len;



	/* decompress the block */

	ret = regcache_lzo_decompress_cache_block(map, lzo_block);

	if (ret < 0) {

		kfree(lzo_block->dst);

		goto out;

	}



	/* write the new value to the cache */

	if (regcache_set_val(map, lzo_block->dst, blkpos, value)) {

		kfree(lzo_block->dst);

		goto out;

	}



	/* prepare the source to be the decompressed block */

	lzo_block->src = lzo_block->dst;

	lzo_block->src_len = lzo_block->dst_len;



	/* compress the block */

	ret = regcache_lzo_compress_cache_block(map, lzo_block);

	if (ret < 0) {

		kfree(lzo_block->dst);

		kfree(lzo_block->src);

		goto out;

	}



	/* set the bit so we know we have to sync this register */

	set_bit(reg / map->reg_stride, lzo_block->sync_bmp);

	kfree(tmp_dst);

	kfree(lzo_block->src);

	return 0;

out:

	lzo_block->dst = tmp_dst;

	lzo_block->dst_len = tmp_dst_len;

	return ret;

}



static int regcache_lzo_sync(struct regmap *map, unsigned int min,

			     unsigned int max)

{

	struct regcache_lzo_ctx **lzo_blocks;

	unsigned int val;

	int i;

	int ret;



	lzo_blocks = map->cache;

	i = min;

	for_each_set_bit_from(i, lzo_blocks[0]->sync_bmp,

			      lzo_blocks[0]->sync_bmp_nbits) {

		if (i > max)

			continue;



		ret = regcache_read(map, i, &val);

		if (ret)

			return ret;



		/* Is this the hardware default?  If so skip. */

		ret = regcache_lookup_reg(map, i);

		if (ret > 0 && val == map->reg_defaults[ret].def)

			continue;



		map->cache_bypass = true;

		ret = _regmap_write(map, i, val);

		map->cache_bypass = false;

		if (ret)

			return ret;

		dev_dbg(map->dev, "Synced register %#x, value %#x\n",

			i, val);

	}



	return 0;

}



struct regcache_ops regcache_lzo_ops = {

	.type = REGCACHE_COMPRESSED,

	.name = "lzo",

	.init = regcache_lzo_init,

	.exit = regcache_lzo_exit,

	.read = regcache_lzo_read,

	.write = regcache_lzo_write,

	.sync = regcache_lzo_sync

};

drivers/base/regmap/regcache-maple.c

0 → 100644
+279 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

//

// Register cache access API - maple tree based cache

//

// Copyright 2023 Arm, Ltd

//

// Author: Mark Brown <broonie@kernel.org>



#include <linux/debugfs.h>

#include <linux/device.h>

#include <linux/maple_tree.h>

#include <linux/slab.h>



#include "internal.h"



static int regcache_maple_read(struct regmap *map,

			       unsigned int reg, unsigned int *value)

{

	struct maple_tree *mt = map->cache;

	MA_STATE(mas, mt, reg, reg);

	unsigned long *entry;



	rcu_read_lock();



	entry = mas_walk(&mas);

	if (!entry) {

		rcu_read_unlock();

		return -ENOENT;

	}



	*value = entry[reg - mas.index];



	rcu_read_unlock();



	return 0;

}



static int regcache_maple_write(struct regmap *map, unsigned int reg,

				unsigned int val)

{

	struct maple_tree *mt = map->cache;

	MA_STATE(mas, mt, reg, reg);

	unsigned long *entry, *upper, *lower;

	unsigned long index, last;

	size_t lower_sz, upper_sz;

	int ret;



	rcu_read_lock();



	entry = mas_walk(&mas);

	if (entry) {

		entry[reg - mas.index] = val;

		rcu_read_unlock();

		return 0;

	}



	/* Any adjacent entries to extend/merge? */

	mas_set_range(&mas, reg - 1, reg + 1);

	index = reg;

	last = reg;



	lower = mas_find(&mas, reg - 1);

	if (lower) {

		index = mas.index;

		lower_sz = (mas.last - mas.index + 1) * sizeof(unsigned long);

	}



	upper = mas_find(&mas, reg + 1);

	if (upper) {

		last = mas.last;

		upper_sz = (mas.last - mas.index + 1) * sizeof(unsigned long);

	}



	rcu_read_unlock();



	entry = kmalloc((last - index + 1) * sizeof(unsigned long),

			GFP_KERNEL);

	if (!entry)

		return -ENOMEM;



	if (lower)

		memcpy(entry, lower, lower_sz);

	entry[reg - index] = val;

	if (upper)

		memcpy(&entry[reg - index + 1], upper, upper_sz);



	/*

	 * This is safe because the regmap lock means the Maple lock

	 * is redundant, but we need to take it due to lockdep asserts

	 * in the maple tree code.

	 */

	mas_lock(&mas);



	mas_set_range(&mas, index, last);

	ret = mas_store_gfp(&mas, entry, GFP_KERNEL);



	mas_unlock(&mas);



	if (ret == 0) {

		kfree(lower);

		kfree(upper);

	}

	

	return ret;

}



static int regcache_maple_drop(struct regmap *map, unsigned int min,

			       unsigned int max)

{

	struct maple_tree *mt = map->cache;

	MA_STATE(mas, mt, min, max);

	unsigned long *entry, *lower, *upper;

	unsigned long lower_index, lower_last;

	unsigned long upper_index, upper_last;

	int ret;



	lower = NULL;

	upper = NULL;



	mas_lock(&mas);



	mas_for_each(&mas, entry, max) {

		/*

		 * This is safe because the regmap lock means the

		 * Maple lock is redundant, but we need to take it due

		 * to lockdep asserts in the maple tree code.

		 */

		mas_unlock(&mas);



		/* Do we need to save any of this entry? */

		if (mas.index < min) {

			lower_index = mas.index;

			lower_last = min -1;



			lower = kmemdup(entry, ((min - mas.index) *

						sizeof(unsigned long)),

					GFP_KERNEL);

			if (!lower) {

				ret = -ENOMEM;

				goto out_unlocked;

			}

		}



		if (mas.last > max) {

			upper_index = max + 1;

			upper_last = mas.last;



			upper = kmemdup(&entry[max + 1],

					((mas.last - max) *

					 sizeof(unsigned long)),

					GFP_KERNEL);

			if (!upper) {

				ret = -ENOMEM;

				goto out_unlocked;

			}

		}



		kfree(entry);

		mas_lock(&mas);

		mas_erase(&mas);



		/* Insert new nodes with the saved data */

		if (lower) {

			mas_set_range(&mas, lower_index, lower_last);

			ret = mas_store_gfp(&mas, lower, GFP_KERNEL);

			if (ret != 0)

				goto out;

			lower = NULL;

		}



		if (upper) {

			mas_set_range(&mas, upper_index, upper_last);

			ret = mas_store_gfp(&mas, upper, GFP_KERNEL);

			if (ret != 0)

				goto out;

			upper = NULL;

		}

	}



out:

	mas_unlock(&mas);

out_unlocked:

	kfree(lower);

	kfree(upper);



	return ret;

}



static int regcache_maple_sync(struct regmap *map, unsigned int min,

			       unsigned int max)

{

	struct maple_tree *mt = map->cache;

	unsigned long *entry;

	MA_STATE(mas, mt, min, max);

	unsigned long lmin = min;

	unsigned long lmax = max;

	unsigned int r;

	int ret;



	map->cache_bypass = true;



	rcu_read_lock();



	mas_for_each(&mas, entry, max) {

		for (r = max(mas.index, lmin); r <= min(mas.last, lmax); r++) {

			ret = regcache_sync_val(map, r, entry[r - mas.index]);

			if (ret != 0)

				goto out;

		}

	}



out:

	rcu_read_unlock();



	map->cache_bypass = false;



	return ret;

}



static int regcache_maple_exit(struct regmap *map)

{

	struct maple_tree *mt = map->cache;

	MA_STATE(mas, mt, 0, UINT_MAX);

	unsigned int *entry;;



	/* if we've already been called then just return */

	if (!mt)

		return 0;



	mas_lock(&mas);

	mas_for_each(&mas, entry, UINT_MAX)

		kfree(entry);

	__mt_destroy(mt);

	mas_unlock(&mas);



	kfree(mt);

	map->cache = NULL;



	return 0;

}



static int regcache_maple_init(struct regmap *map)

{

	struct maple_tree *mt;

	int i;

	int ret;



	mt = kmalloc(sizeof(*mt), GFP_KERNEL);

	if (!mt)

		return -ENOMEM;

	map->cache = mt;



	mt_init(mt);



	for (i = 0; i < map->num_reg_defaults; i++) {

		ret = regcache_maple_write(map,

					   map->reg_defaults[i].reg,

					   map->reg_defaults[i].def);

		if (ret)

			goto err;

	}



	return 0;



err:

	regcache_maple_exit(map);

	return ret;

}



struct regcache_ops regcache_maple_ops = {

	.type = REGCACHE_MAPLE,

	.name = "maple",

	.init = regcache_maple_init,

	.exit = regcache_maple_exit,

	.read = regcache_maple_read,

	.write = regcache_maple_write,

	.drop = regcache_maple_drop,

	.sync = regcache_maple_sync,

};