Skip to contentSkip to conversation

drivers/base/regmap/regmap-mmio.c:222:17: error: implicit declaration of function 'writesq'; did you mean 'writesl'?

PATCH kernel test robot 1 participant 1 message Aug 20, 2022

lore
Share & tools
lore

kernel test robot

author build bot
#0 lore raw
tree:   https://git.kernel.org/pub/scm/linux/kernel/git/linusw/linux-nomadik.git ux500-crypto-fb-stab
head:   8b966d88af5f34992cc041b8c1a3aa8ff6e166d3
commit: fed07372864f56531e05c037ca865ffbe3ceabb3 [2/24] regmap: mmio: Support accelerared noinc operations
config: sparc64-randconfig-s053-20220820 (https://download.01.org/0day-ci/archive/20220820/[email protected]/config)
compiler: sparc64-linux-gcc (GCC) 12.1.0

reproduce:
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
chmod +x ~/bin/make.cross
# apt-get install sparse
# sparse version: v0.6.4-39-gce1a6720-dirty
# https://git.kernel.org/pub/scm/linux/kernel/git/linusw/linux-nomadik.git/commit/?id=fed07372864f56531e05c037ca865ffbe3ceabb3
git remote add linusw-nomadik https://git.kernel.org/pub/scm/linux/kernel/git/linusw/linux-nomadik.git
git fetch --no-tags linusw-nomadik ux500-crypto-fb-stab
git checkout fed07372864f56531e05c037ca865ffbe3ceabb3
# save the config file
mkdir build_dir && cp config build_dir/.config
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=gcc-12.1.0 make.cross C=1 CF='-fdiagnostic-prefix -D__CHECK_ENDIAN__' O=build_dir ARCH=sparc64 SHELL=/bin/bash

If you fix the issue, kindly add following tag where applicable

All errors (new ones prefixed by >>):

drivers/base/regmap/regmap-mmio.c: In function 'regmap_mmio_noinc_write':

>> drivers/base/regmap/regmap-mmio.c:222:17: error: implicit declaration of function 'writesq'; did you mean 'writesl'? [-Werror=implicit-function-declaration]
     222 |                 writesq(ctx->regs + reg, (const u64 *)val, val_count);
         |                 ^~~~~~~
         |                 writesl
   drivers/base/regmap/regmap-mmio.c: In function 'regmap_mmio_noinc_read':
>> drivers/base/regmap/regmap-mmio.c:376:17: error: implicit declaration of function 'readsq'; did you mean 'readsl'? [-Werror=implicit-function-declaration]
     376 |                 readsq(ctx->regs + reg, (u64 *)val, val_count);
         |                 ^~~~~~
         |                 readsl

cc1: some warnings being treated as errors

vim +222 drivers/base/regmap/regmap-mmio.c

163
164 static int regmap_mmio_noinc_write(void *context, unsigned int reg,
165 const void *val, size_t val_count)
166 {
167 struct regmap_mmio_context *ctx = context;
168 int ret = 0;
169 int i;
170
171 if (!IS_ERR(ctx->clk)) {
172 ret = clk_enable(ctx->clk);
173 if (ret < 0)
174 return ret;
175 }
176
177 /*
178 * There are no native, assembly-optimized write single register
179 * operations for big endian, so fall back to emulation if this
180 * is needed. (Single bytes are fine, they are not affected by
181 * endianness.)
182 */
183 if (ctx->big_endian && (ctx->val_bytes > 1)) {
184 switch (ctx->val_bytes) {
185 case 2:
186 {
187 const u16 *valp = (const u16 *)val;
188 for (i = 0; i < val_count; i++)
189 iowrite16be(valp[i], ctx->regs + reg);
190 break;
191 }
192 case 4:
193 {
194 const u32 *valp = (const u32 *)val;
195 for (i = 0; i < val_count; i++)
196 iowrite32be(valp[i], ctx->regs + reg);
197 break;
198 }
199 #ifdef CONFIG_64BIT
200 case 8:
201 /* This is just too esoteric */
202 fallthrough;
203 #endif
204 default:
205 ret = -EINVAL;
206 goto out_clk;
207 }
208 }
209
210 switch (ctx->val_bytes) {
211 case 1:
212 writesb(ctx->regs + reg, (const u8 *)val, val_count);
213 break;
214 case 2:
215 writesw(ctx->regs + reg, (const u16 *)val, val_count);
216 break;
217 case 4:
218 writesl(ctx->regs + reg, (const u32 *)val, val_count);
219 break;
220 #ifdef CONFIG_64BIT
221 case 8:

 > 222			writesq(ctx->regs + reg, (const u64 *)val, val_count);
   223			break;
   224	#endif
   225		default:
   226			ret = -EINVAL;
   227			break;
   228		}
   229	
   230	out_clk:
   231		if (!IS_ERR(ctx->clk))
   232			clk_disable(ctx->clk);
   233	
   234		return ret;
   235	}
   236	
   237	static unsigned int regmap_mmio_read8(struct regmap_mmio_context *ctx,
   238					      unsigned int reg)
   239	{
   240		return readb(ctx->regs + reg);
   241	}
   242	
   243	static unsigned int regmap_mmio_read8_relaxed(struct regmap_mmio_context *ctx,
   244					      unsigned int reg)
   245	{
   246		return readb_relaxed(ctx->regs + reg);
   247	}
   248	
   249	static unsigned int regmap_mmio_read16le(struct regmap_mmio_context *ctx,
   250					         unsigned int reg)
   251	{
   252		return readw(ctx->regs + reg);
   253	}
   254	
   255	static unsigned int regmap_mmio_read16le_relaxed(struct regmap_mmio_context *ctx,
   256							 unsigned int reg)
   257	{
   258		return readw_relaxed(ctx->regs + reg);
   259	}
   260	
   261	static unsigned int regmap_mmio_read16be(struct regmap_mmio_context *ctx,
   262					         unsigned int reg)
   263	{
   264		return ioread16be(ctx->regs + reg);
   265	}
   266	
   267	static unsigned int regmap_mmio_read32le(struct regmap_mmio_context *ctx,
   268					         unsigned int reg)
   269	{
   270		return readl(ctx->regs + reg);
   271	}
   272	
   273	static unsigned int regmap_mmio_read32le_relaxed(struct regmap_mmio_context *ctx,
   274							 unsigned int reg)
   275	{
   276		return readl_relaxed(ctx->regs + reg);
   277	}
   278	
   279	static unsigned int regmap_mmio_read32be(struct regmap_mmio_context *ctx,
   280					         unsigned int reg)
   281	{
   282		return ioread32be(ctx->regs + reg);
   283	}
   284	
   285	#ifdef CONFIG_64BIT
   286	static unsigned int regmap_mmio_read64le(struct regmap_mmio_context *ctx,
   287					         unsigned int reg)
   288	{
   289		return readq(ctx->regs + reg);
   290	}
   291	
   292	static unsigned int regmap_mmio_read64le_relaxed(struct regmap_mmio_context *ctx,
   293							 unsigned int reg)
   294	{
   295		return readq_relaxed(ctx->regs + reg);
   296	}
   297	#endif
   298	
   299	static int regmap_mmio_read(void *context, unsigned int reg, unsigned int *val)
   300	{
   301		struct regmap_mmio_context *ctx = context;
   302		int ret;
   303	
   304		if (!IS_ERR(ctx->clk)) {
   305			ret = clk_enable(ctx->clk);
   306			if (ret < 0)
   307				return ret;
   308		}
   309	
   310		*val = ctx->reg_read(ctx, reg);
   311	
   312		if (!IS_ERR(ctx->clk))
   313			clk_disable(ctx->clk);
   314	
   315		return 0;
   316	}
   317	
   318	static int regmap_mmio_noinc_read(void *context, unsigned int reg,
   319					  void *val, size_t val_count)
   320	{
   321		struct regmap_mmio_context *ctx = context;
   322		int ret = 0;
   323		int i;
   324	
   325		if (!IS_ERR(ctx->clk)) {
   326			ret = clk_enable(ctx->clk);
   327			if (ret < 0)
   328				return ret;
   329		}
   330	
   331		/*
   332		 * There are no native, assembly-optimized write single register
   333		 * operations for big endian, so fall back to emulation if this
   334		 * is needed. (Single bytes are fine, they are not affected by
   335		 * endianness.)
   336		 */
   337		if (ctx->big_endian && (ctx->val_bytes > 1)) {
   338			switch (ctx->val_bytes) {
   339			case 2:
   340			{
   341				u16 *valp = (u16 *)val;
   342				for (i = 0; i < val_count; i++)
   343					valp[i] = ioread16be(ctx->regs + reg);
   344				break;
   345			}
   346			case 4:
   347			{
   348				u32 *valp = (u32 *)val;
   349				for (i = 0; i < val_count; i++)
   350					valp[i] = ioread32be(ctx->regs + reg);
   351				break;
   352			}
   353	#ifdef CONFIG_64BIT
   354			case 8:
   355				/* This is just too esoteric */
   356				fallthrough;
   357	#endif
   358			default:
   359				ret = -EINVAL;
   360				goto out_clk;
   361			}
   362		}
   363	
   364		switch (ctx->val_bytes) {
   365		case 1:
   366			readsb(ctx->regs + reg, (u8 *)val, val_count);
   367			break;
   368		case 2:
   369			readsw(ctx->regs + reg, (u16 *)val, val_count);
   370			break;
   371		case 4:
   372			readsl(ctx->regs + reg, (u32 *)val, val_count);
   373			break;
   374	#ifdef CONFIG_64BIT
   375		case 8:
 > 376			readsq(ctx->regs + reg, (u64 *)val, val_count);

377 break;
378 #endif
379 default:
380 ret = -EINVAL;
381 break;
382 }
383
384 out_clk:
385 if (!IS_ERR(ctx->clk))
386 clk_disable(ctx->clk);
387
388 return ret;
389
390 return 0;
391 }
392

Signature · 7 lines
0-DAY CI Kernel Test Service
https://01.org/lkp

_______________________________________________
linux-arm-kernel mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel