Commit 2a000870 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

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

Pull regmap fixes from Mark Brown:
 "A few small fixes, none of which are likely to have any substantial
  impact here - the most substantial one is a fix for a long standing
  memory leak on devices that use register patching which will only have
  an impact if the device is removed and re-added"

* tag 'regmap-fix-v5.8-rc2' of git://git.kernel.org/pub/scm/linux/kernel/git/broonie/regmap:
  regmap: Fix memory leak from regmap_register_patch
  regmap: fix the kerneldoc for regmap_test_bits()
  regmap: fix alignment issue
parents 625d3449 95b2c3ec

drivers/base/regmap/regmap.c

+50 −56
Original line number Diff line number Diff line
@@ -17,6 +17,7 @@ 
#include <linux/delay.h>

#include <linux/log2.h>

#include <linux/hwspinlock.h>

#include <asm/unaligned.h>



#define CREATE_TRACE_POINTS

#include "trace.h"
@@ -249,22 +250,20 @@ static void regmap_format_8(void *buf, unsigned int val, unsigned int shift) 


static void regmap_format_16_be(void *buf, unsigned int val, unsigned int shift)

{

	__be16 *b = buf;



	b[0] = cpu_to_be16(val << shift);

	put_unaligned_be16(val << shift, buf);

}



static void regmap_format_16_le(void *buf, unsigned int val, unsigned int shift)

{

	__le16 *b = buf;



	b[0] = cpu_to_le16(val << shift);

	put_unaligned_le16(val << shift, buf);

}



static void regmap_format_16_native(void *buf, unsigned int val,

				    unsigned int shift)

{

	*(u16 *)buf = val << shift;

	u16 v = val << shift;



	memcpy(buf, &v, sizeof(v));

}



static void regmap_format_24(void *buf, unsigned int val, unsigned int shift)
@@ -280,43 +279,39 @@ static void regmap_format_24(void *buf, unsigned int val, unsigned int shift) 


static void regmap_format_32_be(void *buf, unsigned int val, unsigned int shift)

{

	__be32 *b = buf;



	b[0] = cpu_to_be32(val << shift);

	put_unaligned_be32(val << shift, buf);

}



static void regmap_format_32_le(void *buf, unsigned int val, unsigned int shift)

{

	__le32 *b = buf;



	b[0] = cpu_to_le32(val << shift);

	put_unaligned_le32(val << shift, buf);

}



static void regmap_format_32_native(void *buf, unsigned int val,

				    unsigned int shift)

{

	*(u32 *)buf = val << shift;

	u32 v = val << shift;



	memcpy(buf, &v, sizeof(v));

}



#ifdef CONFIG_64BIT

static void regmap_format_64_be(void *buf, unsigned int val, unsigned int shift)

{

	__be64 *b = buf;



	b[0] = cpu_to_be64((u64)val << shift);

	put_unaligned_be64((u64) val << shift, buf);

}



static void regmap_format_64_le(void *buf, unsigned int val, unsigned int shift)

{

	__le64 *b = buf;



	b[0] = cpu_to_le64((u64)val << shift);

	put_unaligned_le64((u64) val << shift, buf);

}



static void regmap_format_64_native(void *buf, unsigned int val,

				    unsigned int shift)

{

	*(u64 *)buf = (u64)val << shift;

	u64 v = (u64) val << shift;



	memcpy(buf, &v, sizeof(v));

}

#endif
@@ -333,35 +328,34 @@ static unsigned int regmap_parse_8(const void *buf) 


static unsigned int regmap_parse_16_be(const void *buf)

{

	const __be16 *b = buf;



	return be16_to_cpu(b[0]);

	return get_unaligned_be16(buf);

}



static unsigned int regmap_parse_16_le(const void *buf)

{

	const __le16 *b = buf;



	return le16_to_cpu(b[0]);

	return get_unaligned_le16(buf);

}



static void regmap_parse_16_be_inplace(void *buf)

{

	__be16 *b = buf;

	u16 v = get_unaligned_be16(buf);



	b[0] = be16_to_cpu(b[0]);

	memcpy(buf, &v, sizeof(v));

}



static void regmap_parse_16_le_inplace(void *buf)

{

	__le16 *b = buf;

	u16 v = get_unaligned_le16(buf);



	b[0] = le16_to_cpu(b[0]);

	memcpy(buf, &v, sizeof(v));

}



static unsigned int regmap_parse_16_native(const void *buf)

{

	return *(u16 *)buf;

	u16 v;



	memcpy(&v, buf, sizeof(v));

	return v;

}



static unsigned int regmap_parse_24(const void *buf)
@@ -376,69 +370,67 @@ static unsigned int regmap_parse_24(const void *buf) 


static unsigned int regmap_parse_32_be(const void *buf)

{

	const __be32 *b = buf;



	return be32_to_cpu(b[0]);

	return get_unaligned_be32(buf);

}



static unsigned int regmap_parse_32_le(const void *buf)

{

	const __le32 *b = buf;



	return le32_to_cpu(b[0]);

	return get_unaligned_le32(buf);

}



static void regmap_parse_32_be_inplace(void *buf)

{

	__be32 *b = buf;

	u32 v = get_unaligned_be32(buf);



	b[0] = be32_to_cpu(b[0]);

	memcpy(buf, &v, sizeof(v));

}



static void regmap_parse_32_le_inplace(void *buf)

{

	__le32 *b = buf;

	u32 v = get_unaligned_le32(buf);



	b[0] = le32_to_cpu(b[0]);

	memcpy(buf, &v, sizeof(v));

}



static unsigned int regmap_parse_32_native(const void *buf)

{

	return *(u32 *)buf;

	u32 v;



	memcpy(&v, buf, sizeof(v));

	return v;

}



#ifdef CONFIG_64BIT

static unsigned int regmap_parse_64_be(const void *buf)

{

	const __be64 *b = buf;



	return be64_to_cpu(b[0]);

	return get_unaligned_be64(buf);

}



static unsigned int regmap_parse_64_le(const void *buf)

{

	const __le64 *b = buf;



	return le64_to_cpu(b[0]);

	return get_unaligned_le64(buf);

}



static void regmap_parse_64_be_inplace(void *buf)

{

	__be64 *b = buf;

	u64 v =  get_unaligned_be64(buf);



	b[0] = be64_to_cpu(b[0]);

	memcpy(buf, &v, sizeof(v));

}



static void regmap_parse_64_le_inplace(void *buf)

{

	__le64 *b = buf;

	u64 v = get_unaligned_le64(buf);



	b[0] = le64_to_cpu(b[0]);

	memcpy(buf, &v, sizeof(v));

}



static unsigned int regmap_parse_64_native(const void *buf)

{

	return *(u64 *)buf;

	u64 v;



	memcpy(&v, buf, sizeof(v));

	return v;

}

#endif
@@ -1357,6 +1349,7 @@ void regmap_exit(struct regmap *map) 
	if (map->hwlock)

		hwspin_lock_free(map->hwlock);

	kfree_const(map->name);

	kfree(map->patch);

	kfree(map);

}

EXPORT_SYMBOL_GPL(regmap_exit);
@@ -2944,8 +2937,9 @@ EXPORT_SYMBOL_GPL(regmap_update_bits_base); 
 * @reg: Register to read from

 * @bits: Bits to test

 *

 * Returns -1 if the underlying regmap_read() fails, 0 if at least one of the

 * tested bits is not set and 1 if all tested bits are set.

 * Returns 0 if at least one of the tested bits is not set, 1 if all tested

 * bits are set and a negative error number if the underlying regmap_read()

 * fails.

 */

int regmap_test_bits(struct regmap *map, unsigned int reg, unsigned int bits)

{

CRA Git | Maintained and supported by SUSTech CRA and CCSE