b9eaf18722
This mechanically converts all remaining cases of ancient open-coded timer
setup with the old setup_timer() API, which is the first step in timer
conversions. This has no behavioral changes, since it ultimately just
changes the order of assignment to fields of struct timer_list when
finding variations of:
init_timer(&t);
f.function = timer_callback;
t.data = timer_callback_arg;
to be converted into:
setup_timer(&t, timer_callback, timer_callback_arg);
The conversion is done with the following Coccinelle script, which
is an improved version of scripts/cocci/api/setup_timer.cocci, in the
following ways:
- assignments-before-init_timer() cases
- limit the .data case removal to the specific struct timer_list instance
- handling calls by dereference (timer->field vs timer.field)
spatch --very-quiet --all-includes --include-headers \
-I ./arch/x86/include -I ./arch/x86/include/generated \
-I ./include -I ./arch/x86/include/uapi \
-I ./arch/x86/include/generated/uapi -I ./include/uapi \
-I ./include/generated/uapi --include ./include/linux/kconfig.h \
--dir . \
--cocci-file ~/src/data/setup_timer.cocci
@fix_address_of@
expression e;
@@
init_timer(
-&(e)
+&e
, ...)
// Match the common cases first to avoid Coccinelle parsing loops with
// "... when" clauses.
@match_immediate_function_data_after_init_timer@
expression e, func, da;
@@
-init_timer
+setup_timer
( \(&e\|e\)
+, func, da
);
(
-\(e.function\|e->function\) = func;
-\(e.data\|e->data\) = da;
|
-\(e.data\|e->data\) = da;
-\(e.function\|e->function\) = func;
)
@match_immediate_function_data_before_init_timer@
expression e, func, da;
@@
(
-\(e.function\|e->function\) = func;
-\(e.data\|e->data\) = da;
|
-\(e.data\|e->data\) = da;
-\(e.function\|e->function\) = func;
)
-init_timer
+setup_timer
( \(&e\|e\)
+, func, da
);
@match_function_and_data_after_init_timer@
expression e, e2, e3, e4, e5, func, da;
@@
-init_timer
+setup_timer
( \(&e\|e\)
+, func, da
);
... when != func = e2
when != da = e3
(
-e.function = func;
... when != da = e4
-e.data = da;
|
-e->function = func;
... when != da = e4
-e->data = da;
|
-e.data = da;
... when != func = e5
-e.function = func;
|
-e->data = da;
... when != func = e5
-e->function = func;
)
@match_function_and_data_before_init_timer@
expression e, e2, e3, e4, e5, func, da;
@@
(
-e.function = func;
... when != da = e4
-e.data = da;
|
-e->function = func;
... when != da = e4
-e->data = da;
|
-e.data = da;
... when != func = e5
-e.function = func;
|
-e->data = da;
... when != func = e5
-e->function = func;
)
... when != func = e2
when != da = e3
-init_timer
+setup_timer
( \(&e\|e\)
+, func, da
);
@r1 exists@
expression t;
identifier f;
position p;
@@
f(...) { ... when any
init_timer@p(\(&t\|t\))
... when any
}
@r2 exists@
expression r1.t;
identifier g != r1.f;
expression e8;
@@
g(...) { ... when any
\(t.data\|t->data\) = e8
... when any
}
// It is dangerous to use setup_timer if data field is initialized
// in another function.
@script:python depends on r2@
p << r1.p;
@@
cocci.include_match(False)
@r3@
expression r1.t, func, e7;
position r1.p;
@@
(
-init_timer@p(&t);
+setup_timer(&t, func, 0UL);
... when != func = e7
-t.function = func;
|
-t.function = func;
... when != func = e7
-init_timer@p(&t);
+setup_timer(&t, func, 0UL);
|
-init_timer@p(t);
+setup_timer(t, func, 0UL);
... when != func = e7
-t->function = func;
|
-t->function = func;
... when != func = e7
-init_timer@p(t);
+setup_timer(t, func, 0UL);
)
Signed-off-by: Kees Cook <keescook@chromium.org>
162 lines
3.8 KiB
C
162 lines
3.8 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
#include <linux/pci.h>
|
|
#include <linux/interrupt.h>
|
|
#include <linux/timer.h>
|
|
#include <linux/kernel.h>
|
|
|
|
/*
|
|
* These functions are used early on before PCI scanning is done
|
|
* and all of the pci_dev and pci_bus structures have been created.
|
|
*/
|
|
static struct pci_dev *fake_pci_dev(struct pci_channel *hose,
|
|
int top_bus, int busnr, int devfn)
|
|
{
|
|
static struct pci_dev dev;
|
|
static struct pci_bus bus;
|
|
|
|
dev.bus = &bus;
|
|
dev.sysdata = hose;
|
|
dev.devfn = devfn;
|
|
bus.number = busnr;
|
|
bus.sysdata = hose;
|
|
bus.ops = hose->pci_ops;
|
|
|
|
if(busnr != top_bus)
|
|
/* Fake a parent bus structure. */
|
|
bus.parent = &bus;
|
|
else
|
|
bus.parent = NULL;
|
|
|
|
return &dev;
|
|
}
|
|
|
|
#define EARLY_PCI_OP(rw, size, type) \
|
|
int __init early_##rw##_config_##size(struct pci_channel *hose, \
|
|
int top_bus, int bus, int devfn, int offset, type value) \
|
|
{ \
|
|
return pci_##rw##_config_##size( \
|
|
fake_pci_dev(hose, top_bus, bus, devfn), \
|
|
offset, value); \
|
|
}
|
|
|
|
EARLY_PCI_OP(read, byte, u8 *)
|
|
EARLY_PCI_OP(read, word, u16 *)
|
|
EARLY_PCI_OP(read, dword, u32 *)
|
|
EARLY_PCI_OP(write, byte, u8)
|
|
EARLY_PCI_OP(write, word, u16)
|
|
EARLY_PCI_OP(write, dword, u32)
|
|
|
|
int __init pci_is_66mhz_capable(struct pci_channel *hose,
|
|
int top_bus, int current_bus)
|
|
{
|
|
u32 pci_devfn;
|
|
unsigned short vid;
|
|
int cap66 = -1;
|
|
u16 stat;
|
|
|
|
printk(KERN_INFO "PCI: Checking 66MHz capabilities...\n");
|
|
|
|
for (pci_devfn = 0; pci_devfn < 0xff; pci_devfn++) {
|
|
if (PCI_FUNC(pci_devfn))
|
|
continue;
|
|
if (early_read_config_word(hose, top_bus, current_bus,
|
|
pci_devfn, PCI_VENDOR_ID, &vid) !=
|
|
PCIBIOS_SUCCESSFUL)
|
|
continue;
|
|
if (vid == 0xffff)
|
|
continue;
|
|
|
|
/* check 66MHz capability */
|
|
if (cap66 < 0)
|
|
cap66 = 1;
|
|
if (cap66) {
|
|
early_read_config_word(hose, top_bus, current_bus,
|
|
pci_devfn, PCI_STATUS, &stat);
|
|
if (!(stat & PCI_STATUS_66MHZ)) {
|
|
printk(KERN_DEBUG
|
|
"PCI: %02x:%02x not 66MHz capable.\n",
|
|
current_bus, pci_devfn);
|
|
cap66 = 0;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return cap66 > 0;
|
|
}
|
|
|
|
static void pcibios_enable_err(unsigned long __data)
|
|
{
|
|
struct pci_channel *hose = (struct pci_channel *)__data;
|
|
|
|
del_timer(&hose->err_timer);
|
|
printk(KERN_DEBUG "PCI: re-enabling error IRQ.\n");
|
|
enable_irq(hose->err_irq);
|
|
}
|
|
|
|
static void pcibios_enable_serr(unsigned long __data)
|
|
{
|
|
struct pci_channel *hose = (struct pci_channel *)__data;
|
|
|
|
del_timer(&hose->serr_timer);
|
|
printk(KERN_DEBUG "PCI: re-enabling system error IRQ.\n");
|
|
enable_irq(hose->serr_irq);
|
|
}
|
|
|
|
void pcibios_enable_timers(struct pci_channel *hose)
|
|
{
|
|
if (hose->err_irq) {
|
|
setup_timer(&hose->err_timer, pcibios_enable_err,
|
|
(unsigned long)hose);
|
|
}
|
|
|
|
if (hose->serr_irq) {
|
|
setup_timer(&hose->serr_timer, pcibios_enable_serr,
|
|
(unsigned long)hose);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* A simple handler for the regular PCI status errors, called from IRQ
|
|
* context.
|
|
*/
|
|
unsigned int pcibios_handle_status_errors(unsigned long addr,
|
|
unsigned int status,
|
|
struct pci_channel *hose)
|
|
{
|
|
unsigned int cmd = 0;
|
|
|
|
if (status & PCI_STATUS_REC_MASTER_ABORT) {
|
|
printk(KERN_DEBUG "PCI: master abort, pc=0x%08lx\n", addr);
|
|
cmd |= PCI_STATUS_REC_MASTER_ABORT;
|
|
}
|
|
|
|
if (status & PCI_STATUS_REC_TARGET_ABORT) {
|
|
printk(KERN_DEBUG "PCI: target abort: ");
|
|
pcibios_report_status(PCI_STATUS_REC_TARGET_ABORT |
|
|
PCI_STATUS_SIG_TARGET_ABORT |
|
|
PCI_STATUS_REC_MASTER_ABORT, 1);
|
|
printk("\n");
|
|
|
|
cmd |= PCI_STATUS_REC_TARGET_ABORT;
|
|
}
|
|
|
|
if (status & (PCI_STATUS_PARITY | PCI_STATUS_DETECTED_PARITY)) {
|
|
printk(KERN_DEBUG "PCI: parity error detected: ");
|
|
pcibios_report_status(PCI_STATUS_PARITY |
|
|
PCI_STATUS_DETECTED_PARITY, 1);
|
|
printk("\n");
|
|
|
|
cmd |= PCI_STATUS_PARITY | PCI_STATUS_DETECTED_PARITY;
|
|
|
|
/* Now back off of the IRQ for awhile */
|
|
if (hose->err_irq) {
|
|
disable_irq_nosync(hose->err_irq);
|
|
hose->err_timer.expires = jiffies + HZ;
|
|
add_timer(&hose->err_timer);
|
|
}
|
|
}
|
|
|
|
return cmd;
|
|
}
|