![David Howells](/assets/img/avatar_default.png)
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead of passing regs around manually through all ~1800 interrupt handlers in the Linux kernel. The regs pointer is used in few places, but it potentially costs both stack space and code to pass it around. On the FRV arch, removing the regs parameter from all the genirq function results in a 20% speed up of the IRQ exit path (ie: from leaving timer_interrupt() to leaving do_IRQ()). Where appropriate, an arch may override the generic storage facility and do something different with the variable. On FRV, for instance, the address is maintained in GR28 at all times inside the kernel as part of general exception handling. Having looked over the code, it appears that the parameter may be handed down through up to twenty or so layers of functions. Consider a USB character device attached to a USB hub, attached to a USB controller that posts its interrupts through a cascaded auxiliary interrupt controller. A character device driver may want to pass regs to the sysrq handler through the input layer which adds another few layers of parameter passing. I've build this code with allyesconfig for x86_64 and i386. I've runtested the main part of the code on FRV and i386, though I can't test most of the drivers. I've also done partial conversion for powerpc and MIPS - these at least compile with minimal configurations. This will affect all archs. Mostly the changes should be relatively easy. Take do_IRQ(), store the regs pointer at the beginning, saving the old one: struct pt_regs *old_regs = set_irq_regs(regs); And put the old one back at the end: set_irq_regs(old_regs); Don't pass regs through to generic_handle_irq() or __do_IRQ(). In timer_interrupt(), this sort of change will be necessary: - update_process_times(user_mode(regs)); - profile_tick(CPU_PROFILING, regs); + update_process_times(user_mode(get_irq_regs())); + profile_tick(CPU_PROFILING); I'd like to move update_process_times()'s use of get_irq_regs() into itself, except that i386, alone of the archs, uses something other than user_mode(). Some notes on the interrupt handling in the drivers: (*) input_dev() is now gone entirely. The regs pointer is no longer stored in the input_dev struct. (*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does something different depending on whether it's been supplied with a regs pointer or not. (*) Various IRQ handler function pointers have been moved to type irq_handler_t. Signed-Off-By: David Howells <dhowells@redhat.com> (cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
212 lines
5.4 KiB
C
212 lines
5.4 KiB
C
/*
|
|
* SGI O2 MACE PS2 controller driver for linux
|
|
*
|
|
* Copyright (C) 2002 Vivien Chappelier
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
* published by the Free Software Foundation
|
|
*/
|
|
#include <linux/module.h>
|
|
#include <linux/init.h>
|
|
#include <linux/serio.h>
|
|
#include <linux/errno.h>
|
|
#include <linux/interrupt.h>
|
|
#include <linux/ioport.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/platform_device.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/spinlock.h>
|
|
#include <linux/err.h>
|
|
|
|
#include <asm/io.h>
|
|
#include <asm/irq.h>
|
|
#include <asm/system.h>
|
|
#include <asm/ip32/mace.h>
|
|
#include <asm/ip32/ip32_ints.h>
|
|
|
|
MODULE_AUTHOR("Vivien Chappelier <vivien.chappelier@linux-mips.org");
|
|
MODULE_DESCRIPTION("SGI O2 MACE PS2 controller driver");
|
|
MODULE_LICENSE("GPL");
|
|
|
|
#define MACE_PS2_TIMEOUT 10000 /* in 50us unit */
|
|
|
|
#define PS2_STATUS_CLOCK_SIGNAL BIT(0) /* external clock signal */
|
|
#define PS2_STATUS_CLOCK_INHIBIT BIT(1) /* clken output signal */
|
|
#define PS2_STATUS_TX_INPROGRESS BIT(2) /* transmission in progress */
|
|
#define PS2_STATUS_TX_EMPTY BIT(3) /* empty transmit buffer */
|
|
#define PS2_STATUS_RX_FULL BIT(4) /* full receive buffer */
|
|
#define PS2_STATUS_RX_INPROGRESS BIT(5) /* reception in progress */
|
|
#define PS2_STATUS_ERROR_PARITY BIT(6) /* parity error */
|
|
#define PS2_STATUS_ERROR_FRAMING BIT(7) /* framing error */
|
|
|
|
#define PS2_CONTROL_TX_CLOCK_DISABLE BIT(0) /* inhibit clock signal after TX */
|
|
#define PS2_CONTROL_TX_ENABLE BIT(1) /* transmit enable */
|
|
#define PS2_CONTROL_TX_INT_ENABLE BIT(2) /* enable transmit interrupt */
|
|
#define PS2_CONTROL_RX_INT_ENABLE BIT(3) /* enable receive interrupt */
|
|
#define PS2_CONTROL_RX_CLOCK_ENABLE BIT(4) /* pause reception if set to 0 */
|
|
#define PS2_CONTROL_RESET BIT(5) /* reset */
|
|
|
|
struct maceps2_data {
|
|
struct mace_ps2port *port;
|
|
int irq;
|
|
};
|
|
|
|
static struct maceps2_data port_data[2];
|
|
static struct serio *maceps2_port[2];
|
|
static struct platform_device *maceps2_device;
|
|
|
|
static int maceps2_write(struct serio *dev, unsigned char val)
|
|
{
|
|
struct mace_ps2port *port = ((struct maceps2_data *)dev->port_data)->port;
|
|
unsigned int timeout = MACE_PS2_TIMEOUT;
|
|
|
|
do {
|
|
if (port->status & PS2_STATUS_TX_EMPTY) {
|
|
port->tx = val;
|
|
return 0;
|
|
}
|
|
udelay(50);
|
|
} while (timeout--);
|
|
|
|
return -1;
|
|
}
|
|
|
|
static irqreturn_t maceps2_interrupt(int irq, void *dev_id)
|
|
{
|
|
struct serio *dev = dev_id;
|
|
struct mace_ps2port *port = ((struct maceps2_data *)dev->port_data)->port;
|
|
unsigned long byte;
|
|
|
|
if (port->status & PS2_STATUS_RX_FULL) {
|
|
byte = port->rx;
|
|
serio_interrupt(dev, byte & 0xff, 0);
|
|
}
|
|
|
|
return IRQ_HANDLED;
|
|
}
|
|
|
|
static int maceps2_open(struct serio *dev)
|
|
{
|
|
struct maceps2_data *data = (struct maceps2_data *)dev->port_data;
|
|
|
|
if (request_irq(data->irq, maceps2_interrupt, 0, "PS2 port", dev)) {
|
|
printk(KERN_ERR "Could not allocate PS/2 IRQ\n");
|
|
return -EBUSY;
|
|
}
|
|
|
|
/* Reset port */
|
|
data->port->control = PS2_CONTROL_TX_CLOCK_DISABLE | PS2_CONTROL_RESET;
|
|
udelay(100);
|
|
|
|
/* Enable interrupts */
|
|
data->port->control = PS2_CONTROL_RX_CLOCK_ENABLE |
|
|
PS2_CONTROL_TX_ENABLE |
|
|
PS2_CONTROL_RX_INT_ENABLE;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void maceps2_close(struct serio *dev)
|
|
{
|
|
struct maceps2_data *data = (struct maceps2_data *)dev->port_data;
|
|
|
|
data->port->control = PS2_CONTROL_TX_CLOCK_DISABLE | PS2_CONTROL_RESET;
|
|
udelay(100);
|
|
free_irq(data->irq, dev);
|
|
}
|
|
|
|
|
|
static struct serio * __devinit maceps2_allocate_port(int idx)
|
|
{
|
|
struct serio *serio;
|
|
|
|
serio = kzalloc(sizeof(struct serio), GFP_KERNEL);
|
|
if (serio) {
|
|
serio->id.type = SERIO_8042;
|
|
serio->write = maceps2_write;
|
|
serio->open = maceps2_open;
|
|
serio->close = maceps2_close;
|
|
snprintf(serio->name, sizeof(serio->name), "MACE PS/2 port%d", idx);
|
|
snprintf(serio->phys, sizeof(serio->phys), "mace/serio%d", idx);
|
|
serio->port_data = &port_data[idx];
|
|
serio->dev.parent = &maceps2_device->dev;
|
|
}
|
|
|
|
return serio;
|
|
}
|
|
|
|
static int __devinit maceps2_probe(struct platform_device *dev)
|
|
{
|
|
maceps2_port[0] = maceps2_allocate_port(0);
|
|
maceps2_port[1] = maceps2_allocate_port(1);
|
|
if (!maceps2_port[0] || !maceps2_port[1]) {
|
|
kfree(maceps2_port[0]);
|
|
kfree(maceps2_port[1]);
|
|
return -ENOMEM;
|
|
}
|
|
|
|
serio_register_port(maceps2_port[0]);
|
|
serio_register_port(maceps2_port[1]);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int __devexit maceps2_remove(struct platform_device *dev)
|
|
{
|
|
serio_unregister_port(maceps2_port[0]);
|
|
serio_unregister_port(maceps2_port[1]);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static struct platform_driver maceps2_driver = {
|
|
.driver = {
|
|
.name = "maceps2",
|
|
.owner = THIS_MODULE,
|
|
},
|
|
.probe = maceps2_probe,
|
|
.remove = __devexit_p(maceps2_remove),
|
|
};
|
|
|
|
static int __init maceps2_init(void)
|
|
{
|
|
int error;
|
|
|
|
error = platform_driver_register(&maceps2_driver);
|
|
if (error)
|
|
return error;
|
|
|
|
maceps2_device = platform_device_alloc("maceps2", -1);
|
|
if (!maceps2_device) {
|
|
error = -ENOMEM;
|
|
goto err_unregister_driver;
|
|
}
|
|
|
|
port_data[0].port = &mace->perif.ps2.keyb;
|
|
port_data[0].irq = MACEISA_KEYB_IRQ;
|
|
port_data[1].port = &mace->perif.ps2.mouse;
|
|
port_data[1].irq = MACEISA_MOUSE_IRQ;
|
|
|
|
error = platform_device_add(maceps2_device);
|
|
if (error)
|
|
goto err_free_device;
|
|
|
|
return 0;
|
|
|
|
err_free_device:
|
|
platform_device_put(maceps2_device);
|
|
err_unregister_driver:
|
|
platform_driver_unregister(&maceps2_driver);
|
|
return error;
|
|
}
|
|
|
|
static void __exit maceps2_exit(void)
|
|
{
|
|
platform_device_unregister(maceps2_device);
|
|
platform_driver_unregister(&maceps2_driver);
|
|
}
|
|
|
|
module_init(maceps2_init);
|
|
module_exit(maceps2_exit);
|