Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge branch 'merge' of git://git.kernel.org/pub/scm/linux/kernel/git/benh/powerpc
* 'merge' of git://git.kernel.org/pub/scm/linux/kernel/git/benh/powerpc:
arch/powerpc: use printk_ratelimited instead of printk_ratelimit
powerpc/rtas-rtc: remove sideeffects of printk_ratelimit
powerpc/pseries: remove duplicate SCSI_BNX2_ISCSI in pseries_defconfig
powerpc/e500: fix breakage with fsl_rio_mcheck_exception
powerpc/p1022ds: fix audio-related properties in the device tree
powerpc/85xx: fix NAND_CMD_READID read bytes number
+104
-93
+6
-3
arch/powerpc/boot/dts/p1022ds.dts
+6
-3
arch/powerpc/boot/dts/p1022ds.dts
···
209
209
wm8776:codec@1a {
210
210
compatible = "wlf,wm8776";
211
211
reg = <0x1a>;
212
-
/* MCLK source is a stand-alone oscillator */
213
-
clock-frequency = <12288000>;
212
+
/*
213
+
* clock-frequency will be set by U-Boot if
214
+
* the clock is enabled.
215
+
*/
214
216
};
215
217
};
216
218
···
282
280
codec-handle = <&wm8776>;
283
281
fsl,playback-dma = <&dma00>;
284
282
fsl,capture-dma = <&dma01>;
285
-
fsl,fifo-depth = <16>;
283
+
fsl,fifo-depth = <15>;
284
+
fsl,ssi-asynchronous;
286
285
};
287
286
288
287
dma@c300 {
-1
arch/powerpc/configs/pseries_defconfig
-1
arch/powerpc/configs/pseries_defconfig
+17
-12
arch/powerpc/kernel/rtas-rtc.c
+17
-12
arch/powerpc/kernel/rtas-rtc.c
···
4
4
#include <linux/init.h>
5
5
#include <linux/rtc.h>
6
6
#include <linux/delay.h>
7
+
#include <linux/ratelimit.h>
7
8
#include <asm/prom.h>
8
9
#include <asm/rtas.h>
9
10
#include <asm/time.h>
···
30
29
}
31
30
} while (wait_time && (get_tb() < max_wait_tb));
32
31
33
-
if (error != 0 && printk_ratelimit()) {
34
-
printk(KERN_WARNING "error: reading the clock failed (%d)\n",
35
-
error);
32
+
if (error != 0) {
33
+
printk_ratelimited(KERN_WARNING
34
+
"error: reading the clock failed (%d)\n",
35
+
error);
36
36
return 0;
37
37
}
38
38
···
57
55
58
56
wait_time = rtas_busy_delay_time(error);
59
57
if (wait_time) {
60
-
if (in_interrupt() && printk_ratelimit()) {
58
+
if (in_interrupt()) {
61
59
memset(rtc_tm, 0, sizeof(struct rtc_time));
62
-
printk(KERN_WARNING "error: reading clock"
63
-
" would delay interrupt\n");
60
+
printk_ratelimited(KERN_WARNING
61
+
"error: reading clock "
62
+
"would delay interrupt\n");
64
63
return; /* delay not allowed */
65
64
}
66
65
msleep(wait_time);
67
66
}
68
67
} while (wait_time && (get_tb() < max_wait_tb));
69
68
70
-
if (error != 0 && printk_ratelimit()) {
71
-
printk(KERN_WARNING "error: reading the clock failed (%d)\n",
72
-
error);
69
+
if (error != 0) {
70
+
printk_ratelimited(KERN_WARNING
71
+
"error: reading the clock failed (%d)\n",
72
+
error);
73
73
return;
74
74
}
75
75
···
103
99
}
104
100
} while (wait_time && (get_tb() < max_wait_tb));
105
101
106
-
if (error != 0 && printk_ratelimit())
107
-
printk(KERN_WARNING "error: setting the clock failed (%d)\n",
108
-
error);
102
+
if (error != 0)
103
+
printk_ratelimited(KERN_WARNING
104
+
"error: setting the clock failed (%d)\n",
105
+
error);
109
106
110
107
return 0;
111
108
}
+31
-26
arch/powerpc/kernel/signal_32.c
+31
-26
arch/powerpc/kernel/signal_32.c
···
25
25
#include <linux/errno.h>
26
26
#include <linux/elf.h>
27
27
#include <linux/ptrace.h>
28
+
#include <linux/ratelimit.h>
28
29
#ifdef CONFIG_PPC64
29
30
#include <linux/syscalls.h>
30
31
#include <linux/compat.h>
···
893
892
printk("badframe in handle_rt_signal, regs=%p frame=%p newsp=%lx\n",
894
893
regs, frame, newsp);
895
894
#endif
896
-
if (show_unhandled_signals && printk_ratelimit())
897
-
printk(KERN_INFO "%s[%d]: bad frame in handle_rt_signal32: "
898
-
"%p nip %08lx lr %08lx\n",
899
-
current->comm, current->pid,
900
-
addr, regs->nip, regs->link);
895
+
if (show_unhandled_signals)
896
+
printk_ratelimited(KERN_INFO
897
+
"%s[%d]: bad frame in handle_rt_signal32: "
898
+
"%p nip %08lx lr %08lx\n",
899
+
current->comm, current->pid,
900
+
addr, regs->nip, regs->link);
901
901
902
902
force_sigsegv(sig, current);
903
903
return 0;
···
1060
1058
return 0;
1061
1059
1062
1060
bad:
1063
-
if (show_unhandled_signals && printk_ratelimit())
1064
-
printk(KERN_INFO "%s[%d]: bad frame in sys_rt_sigreturn: "
1065
-
"%p nip %08lx lr %08lx\n",
1066
-
current->comm, current->pid,
1067
-
rt_sf, regs->nip, regs->link);
1061
+
if (show_unhandled_signals)
1062
+
printk_ratelimited(KERN_INFO
1063
+
"%s[%d]: bad frame in sys_rt_sigreturn: "
1064
+
"%p nip %08lx lr %08lx\n",
1065
+
current->comm, current->pid,
1066
+
rt_sf, regs->nip, regs->link);
1068
1067
1069
1068
force_sig(SIGSEGV, current);
1070
1069
return 0;
···
1152
1149
* We kill the task with a SIGSEGV in this situation.
1153
1150
*/
1154
1151
if (do_setcontext(ctx, regs, 1)) {
1155
-
if (show_unhandled_signals && printk_ratelimit())
1156
-
printk(KERN_INFO "%s[%d]: bad frame in "
1157
-
"sys_debug_setcontext: %p nip %08lx "
1158
-
"lr %08lx\n",
1159
-
current->comm, current->pid,
1160
-
ctx, regs->nip, regs->link);
1152
+
if (show_unhandled_signals)
1153
+
printk_ratelimited(KERN_INFO "%s[%d]: bad frame in "
1154
+
"sys_debug_setcontext: %p nip %08lx "
1155
+
"lr %08lx\n",
1156
+
current->comm, current->pid,
1157
+
ctx, regs->nip, regs->link);
1161
1158
1162
1159
force_sig(SIGSEGV, current);
1163
1160
goto out;
···
1239
1236
printk("badframe in handle_signal, regs=%p frame=%p newsp=%lx\n",
1240
1237
regs, frame, newsp);
1241
1238
#endif
1242
-
if (show_unhandled_signals && printk_ratelimit())
1243
-
printk(KERN_INFO "%s[%d]: bad frame in handle_signal32: "
1244
-
"%p nip %08lx lr %08lx\n",
1245
-
current->comm, current->pid,
1246
-
frame, regs->nip, regs->link);
1239
+
if (show_unhandled_signals)
1240
+
printk_ratelimited(KERN_INFO
1241
+
"%s[%d]: bad frame in handle_signal32: "
1242
+
"%p nip %08lx lr %08lx\n",
1243
+
current->comm, current->pid,
1244
+
frame, regs->nip, regs->link);
1247
1245
1248
1246
force_sigsegv(sig, current);
1249
1247
return 0;
···
1292
1288
return 0;
1293
1289
1294
1290
badframe:
1295
-
if (show_unhandled_signals && printk_ratelimit())
1296
-
printk(KERN_INFO "%s[%d]: bad frame in sys_sigreturn: "
1297
-
"%p nip %08lx lr %08lx\n",
1298
-
current->comm, current->pid,
1299
-
addr, regs->nip, regs->link);
1291
+
if (show_unhandled_signals)
1292
+
printk_ratelimited(KERN_INFO
1293
+
"%s[%d]: bad frame in sys_sigreturn: "
1294
+
"%p nip %08lx lr %08lx\n",
1295
+
current->comm, current->pid,
1296
+
addr, regs->nip, regs->link);
1300
1297
1301
1298
force_sig(SIGSEGV, current);
1302
1299
return 0;
+9
-8
arch/powerpc/kernel/signal_64.c
+9
-8
arch/powerpc/kernel/signal_64.c
···
24
24
#include <linux/elf.h>
25
25
#include <linux/ptrace.h>
26
26
#include <linux/module.h>
27
+
#include <linux/ratelimit.h>
27
28
28
29
#include <asm/sigcontext.h>
29
30
#include <asm/ucontext.h>
···
381
380
printk("badframe in sys_rt_sigreturn, regs=%p uc=%p &uc->uc_mcontext=%p\n",
382
381
regs, uc, &uc->uc_mcontext);
383
382
#endif
384
-
if (show_unhandled_signals && printk_ratelimit())
385
-
printk(regs->msr & MSR_64BIT ? fmt64 : fmt32,
386
-
current->comm, current->pid, "rt_sigreturn",
387
-
(long)uc, regs->nip, regs->link);
383
+
if (show_unhandled_signals)
384
+
printk_ratelimited(regs->msr & MSR_64BIT ? fmt64 : fmt32,
385
+
current->comm, current->pid, "rt_sigreturn",
386
+
(long)uc, regs->nip, regs->link);
388
387
389
388
force_sig(SIGSEGV, current);
390
389
return 0;
···
469
468
printk("badframe in setup_rt_frame, regs=%p frame=%p newsp=%lx\n",
470
469
regs, frame, newsp);
471
470
#endif
472
-
if (show_unhandled_signals && printk_ratelimit())
473
-
printk(regs->msr & MSR_64BIT ? fmt64 : fmt32,
474
-
current->comm, current->pid, "setup_rt_frame",
475
-
(long)frame, regs->nip, regs->link);
471
+
if (show_unhandled_signals)
472
+
printk_ratelimited(regs->msr & MSR_64BIT ? fmt64 : fmt32,
473
+
current->comm, current->pid, "setup_rt_frame",
474
+
(long)frame, regs->nip, regs->link);
476
475
477
476
force_sigsegv(signr, current);
478
477
return 0;
+11
-13
arch/powerpc/kernel/traps.c
+11
-13
arch/powerpc/kernel/traps.c
···
34
34
#include <linux/bug.h>
35
35
#include <linux/kdebug.h>
36
36
#include <linux/debugfs.h>
37
+
#include <linux/ratelimit.h>
37
38
38
39
#include <asm/emulated_ops.h>
39
40
#include <asm/pgtable.h>
···
198
197
if (die("Exception in kernel mode", regs, signr))
199
198
return;
200
199
} else if (show_unhandled_signals &&
201
-
unhandled_signal(current, signr) &&
202
-
printk_ratelimit()) {
203
-
printk(regs->msr & MSR_64BIT ? fmt64 : fmt32,
204
-
current->comm, current->pid, signr,
205
-
addr, regs->nip, regs->link, code);
206
-
}
200
+
unhandled_signal(current, signr)) {
201
+
printk_ratelimited(regs->msr & MSR_64BIT ? fmt64 : fmt32,
202
+
current->comm, current->pid, signr,
203
+
addr, regs->nip, regs->link, code);
204
+
}
207
205
208
206
memset(&info, 0, sizeof(info));
209
207
info.si_signo = signr;
···
425
425
unsigned long reason = mcsr;
426
426
int recoverable = 1;
427
427
428
-
if (reason & MCSR_BUS_RBERR) {
428
+
if (reason & MCSR_LD) {
429
429
recoverable = fsl_rio_mcheck_exception(regs);
430
430
if (recoverable == 1)
431
431
goto silent_out;
···
1342
1342
} else {
1343
1343
/* didn't recognize the instruction */
1344
1344
/* XXX quick hack for now: set the non-Java bit in the VSCR */
1345
-
if (printk_ratelimit())
1346
-
printk(KERN_ERR "Unrecognized altivec instruction "
1347
-
"in %s at %lx\n", current->comm, regs->nip);
1345
+
printk_ratelimited(KERN_ERR "Unrecognized altivec instruction "
1346
+
"in %s at %lx\n", current->comm, regs->nip);
1348
1347
current->thread.vscr.u[3] |= 0x10000;
1349
1348
}
1350
1349
}
···
1547
1548
1548
1549
void ppc_warn_emulated_print(const char *type)
1549
1550
{
1550
-
if (printk_ratelimit())
1551
-
pr_warning("%s used emulated %s instruction\n", current->comm,
1552
-
type);
1551
+
pr_warn_ratelimited("%s used emulated %s instruction\n", current->comm,
1552
+
type);
1553
1553
}
1554
1554
1555
1555
static int __init ppc_warn_emulated_init(void)
+5
-5
arch/powerpc/mm/fault.c
+5
-5
arch/powerpc/mm/fault.c
···
31
31
#include <linux/kdebug.h>
32
32
#include <linux/perf_event.h>
33
33
#include <linux/magic.h>
34
+
#include <linux/ratelimit.h>
34
35
35
36
#include <asm/firmware.h>
36
37
#include <asm/page.h>
···
347
346
return 0;
348
347
}
349
348
350
-
if (is_exec && (error_code & DSISR_PROTFAULT)
351
-
&& printk_ratelimit())
352
-
printk(KERN_CRIT "kernel tried to execute NX-protected"
353
-
" page (%lx) - exploit attempt? (uid: %d)\n",
354
-
address, current_uid());
349
+
if (is_exec && (error_code & DSISR_PROTFAULT))
350
+
printk_ratelimited(KERN_CRIT "kernel tried to execute NX-protected"
351
+
" page (%lx) - exploit attempt? (uid: %d)\n",
352
+
address, current_uid());
355
353
356
354
return SIGSEGV;
357
355
+17
-16
arch/powerpc/sysdev/fsl_rio.c
+17
-16
arch/powerpc/sysdev/fsl_rio.c
···
283
283
#ifdef CONFIG_E500
284
284
int fsl_rio_mcheck_exception(struct pt_regs *regs)
285
285
{
286
-
const struct exception_table_entry *entry = NULL;
287
-
unsigned long reason = mfspr(SPRN_MCSR);
286
+
const struct exception_table_entry *entry;
287
+
unsigned long reason;
288
288
289
-
if (reason & MCSR_BUS_RBERR) {
290
-
reason = in_be32((u32 *)(rio_regs_win + RIO_LTLEDCSR));
291
-
if (reason & (RIO_LTLEDCSR_IER | RIO_LTLEDCSR_PRT)) {
292
-
/* Check if we are prepared to handle this fault */
293
-
entry = search_exception_tables(regs->nip);
294
-
if (entry) {
295
-
pr_debug("RIO: %s - MC Exception handled\n",
296
-
__func__);
297
-
out_be32((u32 *)(rio_regs_win + RIO_LTLEDCSR),
298
-
0);
299
-
regs->msr |= MSR_RI;
300
-
regs->nip = entry->fixup;
301
-
return 1;
302
-
}
289
+
if (!rio_regs_win)
290
+
return 0;
291
+
292
+
reason = in_be32((u32 *)(rio_regs_win + RIO_LTLEDCSR));
293
+
if (reason & (RIO_LTLEDCSR_IER | RIO_LTLEDCSR_PRT)) {
294
+
/* Check if we are prepared to handle this fault */
295
+
entry = search_exception_tables(regs->nip);
296
+
if (entry) {
297
+
pr_debug("RIO: %s - MC Exception handled\n",
298
+
__func__);
299
+
out_be32((u32 *)(rio_regs_win + RIO_LTLEDCSR),
300
+
0);
301
+
regs->msr |= MSR_RI;
302
+
regs->nip = entry->fixup;
303
+
return 1;
303
304
}
304
305
}
305
306
+5
-6
arch/powerpc/sysdev/mpic.c
+5
-6
arch/powerpc/sysdev/mpic.c
···
29
29
#include <linux/pci.h>
30
30
#include <linux/slab.h>
31
31
#include <linux/syscore_ops.h>
32
+
#include <linux/ratelimit.h>
32
33
33
34
#include <asm/ptrace.h>
34
35
#include <asm/signal.h>
···
1649
1648
return NO_IRQ;
1650
1649
}
1651
1650
if (unlikely(mpic->protected && test_bit(src, mpic->protected))) {
1652
-
if (printk_ratelimit())
1653
-
printk(KERN_WARNING "%s: Got protected source %d !\n",
1654
-
mpic->name, (int)src);
1651
+
printk_ratelimited(KERN_WARNING "%s: Got protected source %d !\n",
1652
+
mpic->name, (int)src);
1655
1653
mpic_eoi(mpic);
1656
1654
return NO_IRQ;
1657
1655
}
···
1688
1688
return NO_IRQ;
1689
1689
}
1690
1690
if (unlikely(mpic->protected && test_bit(src, mpic->protected))) {
1691
-
if (printk_ratelimit())
1692
-
printk(KERN_WARNING "%s: Got protected source %d !\n",
1693
-
mpic->name, (int)src);
1691
+
printk_ratelimited(KERN_WARNING "%s: Got protected source %d !\n",
1692
+
mpic->name, (int)src);
1694
1693
return NO_IRQ;
1695
1694
}
1696
1695
+3
-3
drivers/mtd/nand/fsl_elbc_nand.c
+3
-3
drivers/mtd/nand/fsl_elbc_nand.c
···
339
339
(FIR_OP_UA << FIR_OP1_SHIFT) |
340
340
(FIR_OP_RBW << FIR_OP2_SHIFT));
341
341
out_be32(&lbc->fcr, NAND_CMD_READID << FCR_CMD0_SHIFT);
342
-
/* 5 bytes for manuf, device and exts */
343
-
out_be32(&lbc->fbcr, 5);
344
-
elbc_fcm_ctrl->read_bytes = 5;
342
+
/* nand_get_flash_type() reads 8 bytes of entire ID string */
343
+
out_be32(&lbc->fbcr, 8);
344
+
elbc_fcm_ctrl->read_bytes = 8;
345
345
elbc_fcm_ctrl->use_mdr = 1;
346
346
elbc_fcm_ctrl->mdr = 0;
347
347