[linusw-nomadik:ux500-crypto-fb-stab 2/24] drivers/base/regmap/regmap-mmio.c:212:17: error: implicit declaration of function 'writesb'; did you mean 'writeb'?
kernel test robot
lkp at intel.com
Tue Aug 16 21:18:27 PDT 2022
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: parisc-buildonly-randconfig-r003-20220815 (https://download.01.org/0day-ci/archive/20220817/202208171253.TGzjP67J-lkp@intel.com/config)
compiler: hppa-linux-gcc (GCC) 12.1.0
reproduce (this is a W=1 build):
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
chmod +x ~/bin/make.cross
# 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 W=1 O=build_dir ARCH=parisc SHELL=/bin/bash
If you fix the issue, kindly add following tag where applicable
Reported-by: kernel test robot <lkp at intel.com>
All errors (new ones prefixed by >>):
drivers/base/regmap/regmap-mmio.c: In function 'regmap_mmio_noinc_write':
>> drivers/base/regmap/regmap-mmio.c:212:17: error: implicit declaration of function 'writesb'; did you mean 'writeb'? [-Werror=implicit-function-declaration]
212 | writesb(ctx->regs + reg, (const u8 *)val, val_count);
| ^~~~~~~
| writeb
>> drivers/base/regmap/regmap-mmio.c:215:17: error: implicit declaration of function 'writesw'; did you mean 'writew'? [-Werror=implicit-function-declaration]
215 | writesw(ctx->regs + reg, (const u16 *)val, val_count);
| ^~~~~~~
| writew
>> drivers/base/regmap/regmap-mmio.c:218:17: error: implicit declaration of function 'writesl'; did you mean 'writel'? [-Werror=implicit-function-declaration]
218 | writesl(ctx->regs + reg, (const u32 *)val, val_count);
| ^~~~~~~
| writel
drivers/base/regmap/regmap-mmio.c: In function 'regmap_mmio_noinc_read':
>> drivers/base/regmap/regmap-mmio.c:366:17: error: implicit declaration of function 'readsb'; did you mean 'readb'? [-Werror=implicit-function-declaration]
366 | readsb(ctx->regs + reg, (u8 *)val, val_count);
| ^~~~~~
| readb
>> drivers/base/regmap/regmap-mmio.c:369:17: error: implicit declaration of function 'readsw'; did you mean 'readw'? [-Werror=implicit-function-declaration]
369 | readsw(ctx->regs + reg, (u16 *)val, val_count);
| ^~~~~~
| readw
>> drivers/base/regmap/regmap-mmio.c:372:17: error: implicit declaration of function 'readsl'; did you mean 'readl'? [-Werror=implicit-function-declaration]
372 | readsl(ctx->regs + reg, (u32 *)val, val_count);
| ^~~~~~
| readl
cc1: some warnings being treated as errors
vim +212 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
--
0-DAY CI Kernel Test Service
https://01.org/lkp
More information about the linux-arm-kernel
mailing list