Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/sparc
Pull sparc fixes from David Miller:
1) Do serial locking in a way that makes things clear that these are
IRQ spinlocks.
2) Conversion to generic idle loop broke first generation Niagara
machines, need to have %pil interrupts enabled during cpu yield
hypervisor call.
3) Do not use magic constants for iterations over tsb tables, from Doug
Wilson.
4) Fix erroneous truncation of 64-bit system call return values to
32-bit. From Dave Kleikamp.
* git://git.kernel.org/pub/scm/linux/kernel/git/davem/sparc:
sparc64: Make sure %pil interrupts are enabled during hypervisor yield.
sparc64:tsb.c:use array size macro rather than number
sparc64: don't treat 64-bit syscall return codes as 32-bit
sparc: serial: Clean up the locking for -rt
+31
-43
+3
-1
arch/sparc/kernel/process_64.c
+3
-1
arch/sparc/kernel/process_64.c
···
58
58
{
59
59
if (tlb_type != hypervisor) {
60
60
touch_nmi_watchdog();
61
+
local_irq_enable();
61
62
} else {
62
63
unsigned long pstate;
64
+
65
+
local_irq_enable();
63
66
64
67
/* The sun4v sleeping code requires that we have PSTATE.IE cleared over
65
68
* the cpu sleep hypervisor call.
···
85
82
: "=&r" (pstate)
86
83
: "i" (PSTATE_IE));
87
84
}
88
-
local_irq_enable();
89
85
}
90
86
91
87
#ifdef CONFIG_HOTPLUG_CPU
+2
-2
arch/sparc/kernel/syscalls.S
+2
-2
arch/sparc/kernel/syscalls.S
···
189
189
mov %i0, %l5 ! IEU1
190
190
5: call %l7 ! CTI Group brk forced
191
191
srl %i5, 0, %o5 ! IEU1
192
-
ba,a,pt %xcc, 3f
192
+
ba,pt %xcc, 3f
193
+
sra %o0, 0, %o0
193
194
194
195
/* Linux native system calls enter here... */
195
196
.align 32
···
218
217
3: stx %o0, [%sp + PTREGS_OFF + PT_V9_I0]
219
218
ret_sys_call:
220
219
ldx [%sp + PTREGS_OFF + PT_V9_TSTATE], %g3
221
-
sra %o0, 0, %o0
222
220
mov %ulo(TSTATE_XCARRY | TSTATE_ICARRY), %g2
223
221
sllx %g2, 32, %g2
224
222
+1
-1
arch/sparc/mm/tsb.c
+1
-1
arch/sparc/mm/tsb.c
+10
-12
drivers/tty/serial/sunhv.c
+10
-12
drivers/tty/serial/sunhv.c
···
433
433
unsigned long flags;
434
434
int locked = 1;
435
435
436
-
local_irq_save(flags);
437
-
if (port->sysrq) {
438
-
locked = 0;
439
-
} else if (oops_in_progress) {
440
-
locked = spin_trylock(&port->lock);
441
-
} else
442
-
spin_lock(&port->lock);
436
+
if (port->sysrq || oops_in_progress)
437
+
locked = spin_trylock_irqsave(&port->lock, flags);
438
+
else
439
+
spin_lock_irqsave(&port->lock, flags);
443
440
444
441
while (n > 0) {
445
442
unsigned long ra = __pa(con_write_page);
···
467
470
}
468
471
469
472
if (locked)
470
-
spin_unlock(&port->lock);
471
-
local_irq_restore(flags);
473
+
spin_unlock_irqrestore(&port->lock, flags);
472
474
}
473
475
474
476
static inline void sunhv_console_putchar(struct uart_port *port, char c)
···
488
492
unsigned long flags;
489
493
int i, locked = 1;
490
494
491
-
local_irq_save(flags);
495
+
if (port->sysrq || oops_in_progress)
496
+
locked = spin_trylock_irqsave(&port->lock, flags);
497
+
else
498
+
spin_lock_irqsave(&port->lock, flags);
492
499
if (port->sysrq) {
493
500
locked = 0;
494
501
} else if (oops_in_progress) {
···
506
507
}
507
508
508
509
if (locked)
509
-
spin_unlock(&port->lock);
510
-
local_irq_restore(flags);
510
+
spin_unlock_irqrestore(&port->lock, flags);
511
511
}
512
512
513
513
static struct console sunhv_console = {
+5
-9
drivers/tty/serial/sunsab.c
+5
-9
drivers/tty/serial/sunsab.c
···
844
844
unsigned long flags;
845
845
int locked = 1;
846
846
847
-
local_irq_save(flags);
848
-
if (up->port.sysrq) {
849
-
locked = 0;
850
-
} else if (oops_in_progress) {
851
-
locked = spin_trylock(&up->port.lock);
852
-
} else
853
-
spin_lock(&up->port.lock);
847
+
if (up->port.sysrq || oops_in_progress)
848
+
locked = spin_trylock_irqsave(&up->port.lock, flags);
849
+
else
850
+
spin_lock_irqsave(&up->port.lock, flags);
854
851
855
852
uart_console_write(&up->port, s, n, sunsab_console_putchar);
856
853
sunsab_tec_wait(up);
857
854
858
855
if (locked)
859
-
spin_unlock(&up->port.lock);
860
-
local_irq_restore(flags);
856
+
spin_unlock_irqrestore(&up->port.lock, flags);
861
857
}
862
858
863
859
static int sunsab_console_setup(struct console *con, char *options)
+5
-9
drivers/tty/serial/sunsu.c
+5
-9
drivers/tty/serial/sunsu.c
···
1295
1295
unsigned int ier;
1296
1296
int locked = 1;
1297
1297
1298
-
local_irq_save(flags);
1299
-
if (up->port.sysrq) {
1300
-
locked = 0;
1301
-
} else if (oops_in_progress) {
1302
-
locked = spin_trylock(&up->port.lock);
1303
-
} else
1304
-
spin_lock(&up->port.lock);
1298
+
if (up->port.sysrq || oops_in_progress)
1299
+
locked = spin_trylock_irqsave(&up->port.lock, flags);
1300
+
else
1301
+
spin_lock_irqsave(&up->port.lock, flags);
1305
1302
1306
1303
/*
1307
1304
* First save the UER then disable the interrupts
···
1316
1319
serial_out(up, UART_IER, ier);
1317
1320
1318
1321
if (locked)
1319
-
spin_unlock(&up->port.lock);
1320
-
local_irq_restore(flags);
1322
+
spin_unlock_irqrestore(&up->port.lock, flags);
1321
1323
}
1322
1324
1323
1325
/*
+5
-9
drivers/tty/serial/sunzilog.c
+5
-9
drivers/tty/serial/sunzilog.c
···
1195
1195
unsigned long flags;
1196
1196
int locked = 1;
1197
1197
1198
-
local_irq_save(flags);
1199
-
if (up->port.sysrq) {
1200
-
locked = 0;
1201
-
} else if (oops_in_progress) {
1202
-
locked = spin_trylock(&up->port.lock);
1203
-
} else
1204
-
spin_lock(&up->port.lock);
1198
+
if (up->port.sysrq || oops_in_progress)
1199
+
locked = spin_trylock_irqsave(&up->port.lock, flags);
1200
+
else
1201
+
spin_lock_irqsave(&up->port.lock, flags);
1205
1202
1206
1203
uart_console_write(&up->port, s, count, sunzilog_putchar);
1207
1204
udelay(2);
1208
1205
1209
1206
if (locked)
1210
-
spin_unlock(&up->port.lock);
1211
-
local_irq_restore(flags);
1207
+
spin_unlock_irqrestore(&up->port.lock, flags);
1212
1208
}
1213
1209
1214
1210
static int __init sunzilog_console_setup(struct console *con, char *options)