Added missing tegra files.HEADmaster

4 files changed, 735 insertions, 0 deletions

diff --git a/arch/mips/kernel/cpufreq/loongson2_clock.c b/arch/mips/kernel/cpufreq/loongson2_clock.c
new file mode 100644
index 00000000000..cefc6e259ba
--- /dev/null
+++ b/arch/mips/kernel/cpufreq/loongson2_clock.c
@@ -0,0 +1,170 @@
+/*
+ * Copyright (C) 2006 - 2008 Lemote Inc. & Insititute of Computing Technology
+ * Author: Yanhua, yanh@lemote.com
+ *
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ */
+
+#include <linux/cpufreq.h>
+#include <linux/platform_device.h>
+
+#include <asm/clock.h>
+
+#include <loongson.h>
+
+static LIST_HEAD(clock_list);
+static DEFINE_SPINLOCK(clock_lock);
+static DEFINE_MUTEX(clock_list_sem);
+
+/* Minimum CLK support */
+enum {
+        DC_ZERO, DC_25PT = 2, DC_37PT, DC_50PT, DC_62PT, DC_75PT,
+        DC_87PT, DC_DISABLE, DC_RESV
+};
+
+struct cpufreq_frequency_table loongson2_clockmod_table[] = {
+        {DC_RESV, CPUFREQ_ENTRY_INVALID},
+        {DC_ZERO, CPUFREQ_ENTRY_INVALID},
+        {DC_25PT, 0},
+        {DC_37PT, 0},
+        {DC_50PT, 0},
+        {DC_62PT, 0},
+        {DC_75PT, 0},
+        {DC_87PT, 0},
+        {DC_DISABLE, 0},
+        {DC_RESV, CPUFREQ_TABLE_END},
+};
+EXPORT_SYMBOL_GPL(loongson2_clockmod_table);
+
+static struct clk cpu_clk = {
+        .name = "cpu_clk",
+        .flags = CLK_ALWAYS_ENABLED | CLK_RATE_PROPAGATES,
+        .rate = 800000000,
+};
+
+struct clk *clk_get(struct device *dev, const char *id)
+{
+        return &cpu_clk;
+}
+EXPORT_SYMBOL(clk_get);
+
+static void propagate_rate(struct clk *clk)
+{
+        struct clk *clkp;
+
+        list_for_each_entry(clkp, &clock_list, node) {
+                if (likely(clkp->parent != clk))
+                        continue;
+                if (likely(clkp->ops && clkp->ops->recalc))
+                        clkp->ops->recalc(clkp);
+                if (unlikely(clkp->flags & CLK_RATE_PROPAGATES))
+                        propagate_rate(clkp);
+        }
+}
+
+int clk_enable(struct clk *clk)
+{
+        return 0;
+}
+EXPORT_SYMBOL(clk_enable);
+
+void clk_disable(struct clk *clk)
+{
+}
+EXPORT_SYMBOL(clk_disable);
+
+unsigned long clk_get_rate(struct clk *clk)
+{
+        return (unsigned long)clk->rate;
+}
+EXPORT_SYMBOL(clk_get_rate);
+
+void clk_put(struct clk *clk)
+{
+}
+EXPORT_SYMBOL(clk_put);
+
+int clk_set_rate(struct clk *clk, unsigned long rate)
+{
+        return clk_set_rate_ex(clk, rate, 0);
+}
+EXPORT_SYMBOL_GPL(clk_set_rate);
+
+int clk_set_rate_ex(struct clk *clk, unsigned long rate, int algo_id)
+{
+        int ret = 0;
+        int regval;
+        int i;
+
+        if (likely(clk->ops && clk->ops->set_rate)) {
+                unsigned long flags;
+
+                spin_lock_irqsave(&clock_lock, flags);
+                ret = clk->ops->set_rate(clk, rate, algo_id);
+                spin_unlock_irqrestore(&clock_lock, flags);
+        }
+
+        if (unlikely(clk->flags & CLK_RATE_PROPAGATES))
+                propagate_rate(clk);
+
+        for (i = 0; loongson2_clockmod_table[i].frequency != CPUFREQ_TABLE_END;
+             i++) {
+                if (loongson2_clockmod_table[i].frequency ==
+                    CPUFREQ_ENTRY_INVALID)
+                        continue;
+                if (rate == loongson2_clockmod_table[i].frequency)
+                        break;
+        }
+        if (rate != loongson2_clockmod_table[i].frequency)
+                return -ENOTSUPP;
+
+        clk->rate = rate;
+
+        regval = LOONGSON_CHIPCFG0;
+        regval = (regval & ~0x7) | (loongson2_clockmod_table[i].index - 1);
+        LOONGSON_CHIPCFG0 = regval;
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(clk_set_rate_ex);
+
+long clk_round_rate(struct clk *clk, unsigned long rate)
+{
+        if (likely(clk->ops && clk->ops->round_rate)) {
+                unsigned long flags, rounded;
+
+                spin_lock_irqsave(&clock_lock, flags);
+                rounded = clk->ops->round_rate(clk, rate);
+                spin_unlock_irqrestore(&clock_lock, flags);
+
+                return rounded;
+        }
+
+        return rate;
+}
+EXPORT_SYMBOL_GPL(clk_round_rate);
+
+/*
+ * This is the simple version of Loongson-2 wait, Maybe we need do this in
+ * interrupt disabled content
+ */
+
+DEFINE_SPINLOCK(loongson2_wait_lock);
+void loongson2_cpu_wait(void)
+{
+        u32 cpu_freq;
+        unsigned long flags;
+
+        spin_lock_irqsave(&loongson2_wait_lock, flags);
+        cpu_freq = LOONGSON_CHIPCFG0;
+        LOONGSON_CHIPCFG0 &= ~0x7;      /* Put CPU into wait mode */
+        LOONGSON_CHIPCFG0 = cpu_freq;   /* Restore CPU state */
+        spin_unlock_irqrestore(&loongson2_wait_lock, flags);
+}
+EXPORT_SYMBOL_GPL(loongson2_cpu_wait);
+
+MODULE_AUTHOR("Yanhua <yanh@lemote.com>");
+MODULE_DESCRIPTION("cpufreq driver for Loongson 2F");
+MODULE_LICENSE("GPL");
diff --git a/arch/mips/kernel/init_task.c b/arch/mips/kernel/init_task.c
new file mode 100644
index 00000000000..6d6ca530589
--- /dev/null
+++ b/arch/mips/kernel/init_task.c
@@ -0,0 +1,35 @@
+#include <linux/mm.h>
+#include <linux/module.h>
+#include <linux/sched.h>
+#include <linux/init_task.h>
+#include <linux/fs.h>
+#include <linux/mqueue.h>
+
+#include <asm/thread_info.h>
+#include <asm/uaccess.h>
+#include <asm/pgtable.h>
+
+static struct signal_struct init_signals = INIT_SIGNALS(init_signals);
+static struct sighand_struct init_sighand = INIT_SIGHAND(init_sighand);
+/*
+ * Initial thread structure.
+ *
+ * We need to make sure that this is 8192-byte aligned due to the
+ * way process stacks are handled. This is done by making sure
+ * the linker maps this in the .text segment right after head.S,
+ * and making head.S ensure the proper alignment.
+ *
+ * The things we do for performance..
+ */
+union thread_union init_thread_union __init_task_data
+        __attribute__((__aligned__(THREAD_SIZE))) =
+                { INIT_THREAD_INFO(init_task) };
+
+/*
+ * Initial task structure.
+ *
+ * All other task structs will be allocated on slabs in fork.c
+ */
+struct task_struct init_task = INIT_TASK(init_task);
+
+EXPORT_SYMBOL(init_task);
diff --git a/arch/mips/kernel/irq-rm9000.c b/arch/mips/kernel/irq-rm9000.c
new file mode 100644
index 00000000000..38874a4b925
--- /dev/null
+++ b/arch/mips/kernel/irq-rm9000.c
@@ -0,0 +1,107 @@
+/*
+ * Copyright (C) 2003 Ralf Baechle
+ *
+ * This program is free software; you can redistribute  it and/or modify it
+ * under  the terms of  the GNU General  Public License as published by the
+ * Free Software Foundation;  either version 2 of the  License, or (at your
+ * option) any later version.
+ *
+ * Handler for RM9000 extended interrupts.  These are a non-standard
+ * feature so we handle them separately from standard interrupts.
+ */
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/irq.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+
+#include <asm/irq_cpu.h>
+#include <asm/mipsregs.h>
+#include <asm/system.h>
+
+static inline void unmask_rm9k_irq(struct irq_data *d)
+{
+        set_c0_intcontrol(0x1000 << (d->irq - RM9K_CPU_IRQ_BASE));
+}
+
+static inline void mask_rm9k_irq(struct irq_data *d)
+{
+        clear_c0_intcontrol(0x1000 << (d->irq - RM9K_CPU_IRQ_BASE));
+}
+
+static inline void rm9k_cpu_irq_enable(struct irq_data *d)
+{
+        unsigned long flags;
+
+        local_irq_save(flags);
+        unmask_rm9k_irq(d);
+        local_irq_restore(flags);
+}
+
+/*
+ * Performance counter interrupts are global on all processors.
+ */
+static void local_rm9k_perfcounter_irq_startup(void *args)
+{
+        rm9k_cpu_irq_enable(args);
+}
+
+static unsigned int rm9k_perfcounter_irq_startup(struct irq_data *d)
+{
+        on_each_cpu(local_rm9k_perfcounter_irq_startup, d, 1);
+
+        return 0;
+}
+
+static void local_rm9k_perfcounter_irq_shutdown(void *args)
+{
+        unsigned long flags;
+
+        local_irq_save(flags);
+        mask_rm9k_irq(args);
+        local_irq_restore(flags);
+}
+
+static void rm9k_perfcounter_irq_shutdown(struct irq_data *d)
+{
+        on_each_cpu(local_rm9k_perfcounter_irq_shutdown, d, 1);
+}
+
+static struct irq_chip rm9k_irq_controller = {
+        .name = "RM9000",
+        .irq_ack = mask_rm9k_irq,
+        .irq_mask = mask_rm9k_irq,
+        .irq_mask_ack = mask_rm9k_irq,
+        .irq_unmask = unmask_rm9k_irq,
+        .irq_eoi = unmask_rm9k_irq
+};
+
+static struct irq_chip rm9k_perfcounter_irq = {
+        .name = "RM9000",
+        .irq_startup = rm9k_perfcounter_irq_startup,
+        .irq_shutdown = rm9k_perfcounter_irq_shutdown,
+        .irq_ack = mask_rm9k_irq,
+        .irq_mask = mask_rm9k_irq,
+        .irq_mask_ack = mask_rm9k_irq,
+        .irq_unmask = unmask_rm9k_irq,
+};
+
+unsigned int rm9000_perfcount_irq;
+
+EXPORT_SYMBOL(rm9000_perfcount_irq);
+
+void __init rm9k_cpu_irq_init(void)
+{
+        int base = RM9K_CPU_IRQ_BASE;
+        int i;
+
+        clear_c0_intcontrol(0x0000f000);                /* Mask all */
+
+        for (i = base; i < base + 4; i++)
+                irq_set_chip_and_handler(i, &rm9k_irq_controller,
+                                         handle_level_irq);
+
+        rm9000_perfcount_irq = base + 1;
+        irq_set_chip_and_handler(rm9000_perfcount_irq, &rm9k_perfcounter_irq,
+                                 handle_percpu_irq);
+}
diff --git a/arch/mips/kernel/kspd.c b/arch/mips/kernel/kspd.c
new file mode 100644
index 00000000000..29811f04339
--- /dev/null
+++ b/arch/mips/kernel/kspd.c
@@ -0,0 +1,423 @@
+/*
+ * Copyright (C) 2005 MIPS Technologies, Inc.  All rights reserved.
+ *
+ *  This program is free software; you can distribute it and/or modify it
+ *  under the terms of the GNU General Public License (Version 2) as
+ *  published by the Free Software Foundation.
+ *
+ *  This program is distributed in the hope it will be useful, but WITHOUT
+ *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ *  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ *  for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
+ *
+ */
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/sched.h>
+#include <linux/unistd.h>
+#include <linux/file.h>
+#include <linux/fdtable.h>
+#include <linux/fs.h>
+#include <linux/syscalls.h>
+#include <linux/workqueue.h>
+#include <linux/errno.h>
+#include <linux/list.h>
+
+#include <asm/vpe.h>
+#include <asm/rtlx.h>
+#include <asm/kspd.h>
+
+static struct workqueue_struct *workqueue;
+static struct work_struct work;
+
+extern unsigned long cpu_khz;
+
+struct mtsp_syscall {
+        int cmd;
+        unsigned char abi;
+        unsigned char size;
+};
+
+struct mtsp_syscall_ret {
+        int retval;
+        int errno;
+};
+
+struct mtsp_syscall_generic {
+        int arg0;
+        int arg1;
+        int arg2;
+        int arg3;
+        int arg4;
+        int arg5;
+        int arg6;
+};
+
+static struct list_head kspd_notifylist;
+static int sp_stopping;
+
+/* these should match with those in the SDE kit */
+#define MTSP_SYSCALL_BASE       0
+#define MTSP_SYSCALL_EXIT       (MTSP_SYSCALL_BASE + 0)
+#define MTSP_SYSCALL_OPEN       (MTSP_SYSCALL_BASE + 1)
+#define MTSP_SYSCALL_READ       (MTSP_SYSCALL_BASE + 2)
+#define MTSP_SYSCALL_WRITE      (MTSP_SYSCALL_BASE + 3)
+#define MTSP_SYSCALL_CLOSE      (MTSP_SYSCALL_BASE + 4)
+#define MTSP_SYSCALL_LSEEK32    (MTSP_SYSCALL_BASE + 5)
+#define MTSP_SYSCALL_ISATTY     (MTSP_SYSCALL_BASE + 6)
+#define MTSP_SYSCALL_GETTIME    (MTSP_SYSCALL_BASE + 7)
+#define MTSP_SYSCALL_PIPEFREQ   (MTSP_SYSCALL_BASE + 8)
+#define MTSP_SYSCALL_GETTOD     (MTSP_SYSCALL_BASE + 9)
+#define MTSP_SYSCALL_IOCTL     (MTSP_SYSCALL_BASE + 10)
+
+#define MTSP_O_RDONLY           0x0000
+#define MTSP_O_WRONLY           0x0001
+#define MTSP_O_RDWR             0x0002
+#define MTSP_O_NONBLOCK         0x0004
+#define MTSP_O_APPEND           0x0008
+#define MTSP_O_SHLOCK           0x0010
+#define MTSP_O_EXLOCK           0x0020
+#define MTSP_O_ASYNC            0x0040
+/* XXX: check which of these is actually O_SYNC vs O_DSYNC */
+#define MTSP_O_FSYNC            O_SYNC
+#define MTSP_O_NOFOLLOW         0x0100
+#define MTSP_O_SYNC             0x0080
+#define MTSP_O_CREAT            0x0200
+#define MTSP_O_TRUNC            0x0400
+#define MTSP_O_EXCL             0x0800
+#define MTSP_O_BINARY           0x8000
+
+extern int tclimit;
+
+struct apsp_table  {
+        int sp;
+        int ap;
+};
+
+/* we might want to do the mode flags too */
+struct apsp_table open_flags_table[] = {
+        { MTSP_O_RDWR, O_RDWR },
+        { MTSP_O_WRONLY, O_WRONLY },
+        { MTSP_O_CREAT, O_CREAT },
+        { MTSP_O_TRUNC, O_TRUNC },
+        { MTSP_O_NONBLOCK, O_NONBLOCK },
+        { MTSP_O_APPEND, O_APPEND },
+        { MTSP_O_NOFOLLOW, O_NOFOLLOW }
+};
+
+struct apsp_table syscall_command_table[] = {
+        { MTSP_SYSCALL_OPEN, __NR_open },
+        { MTSP_SYSCALL_CLOSE, __NR_close },
+        { MTSP_SYSCALL_READ, __NR_read },
+        { MTSP_SYSCALL_WRITE, __NR_write },
+        { MTSP_SYSCALL_LSEEK32, __NR_lseek },
+        { MTSP_SYSCALL_IOCTL, __NR_ioctl }
+};
+
+static int sp_syscall(int num, int arg0, int arg1, int arg2, int arg3)
+{
+        register long int _num  __asm__("$2") = num;
+        register long int _arg0  __asm__("$4") = arg0;
+        register long int _arg1  __asm__("$5") = arg1;
+        register long int _arg2  __asm__("$6") = arg2;
+        register long int _arg3  __asm__("$7") = arg3;
+
+        mm_segment_t old_fs;
+
+        old_fs = get_fs();
+        set_fs(KERNEL_DS);
+
+        __asm__ __volatile__ (
+        "       syscall                                 \n"
+        : "=r" (_num), "=r" (_arg3)
+        : "r" (_num), "r" (_arg0), "r" (_arg1), "r" (_arg2), "r" (_arg3));
+
+        set_fs(old_fs);
+
+        /* $a3 is error flag */
+        if (_arg3)
+                return -_num;
+
+        return _num;
+}
+
+static int translate_syscall_command(int cmd)
+{
+        int i;
+        int ret = -1;
+
+        for (i = 0; i < ARRAY_SIZE(syscall_command_table); i++) {
+                if ((cmd == syscall_command_table[i].sp))
+                        return syscall_command_table[i].ap;
+        }
+
+        return ret;
+}
+
+static unsigned int translate_open_flags(int flags)
+{
+        int i;
+        unsigned int ret = 0;
+
+        for (i = 0; i < ARRAY_SIZE(open_flags_table); i++) {
+                if( (flags & open_flags_table[i].sp) ) {
+                        ret |= open_flags_table[i].ap;
+                }
+        }
+
+        return ret;
+}
+
+
+static int sp_setfsuidgid(uid_t uid, gid_t gid)
+{
+        struct cred *new;
+
+        new = prepare_creds();
+        if (!new)
+                return -ENOMEM;
+
+        new->fsuid = uid;
+        new->fsgid = gid;
+
+        commit_creds(new);
+
+        return 0;
+}
+
+/*
+ * Expects a request to be on the sysio channel. Reads it.  Decides whether
+ * its a linux syscall and runs it, or whatever.  Puts the return code back
+ * into the request and sends the whole thing back.
+ */
+void sp_work_handle_request(void)
+{
+        struct mtsp_syscall sc;
+        struct mtsp_syscall_generic generic;
+        struct mtsp_syscall_ret ret;
+        struct kspd_notifications *n;
+        unsigned long written;
+        mm_segment_t old_fs;
+        struct timeval tv;
+        struct timezone tz;
+        int err, cmd;
+
+        char *vcwd;
+        int size;
+
+        ret.retval = -1;
+
+        old_fs = get_fs();
+        set_fs(KERNEL_DS);
+
+        if (!rtlx_read(RTLX_CHANNEL_SYSIO, &sc, sizeof(struct mtsp_syscall))) {
+                set_fs(old_fs);
+                printk(KERN_ERR "Expected request but nothing to read\n");
+                return;
+        }
+
+        size = sc.size;
+
+        if (size) {
+                if (!rtlx_read(RTLX_CHANNEL_SYSIO, &generic, size)) {
+                        set_fs(old_fs);
+                        printk(KERN_ERR "Expected request but nothing to read\n");
+                        return;
+                }
+        }
+
+        /* Run the syscall at the privilege of the user who loaded the
+           SP program */
+
+        if (vpe_getuid(tclimit)) {
+                err = sp_setfsuidgid(vpe_getuid(tclimit), vpe_getgid(tclimit));
+                if (!err)
+                        pr_err("Change of creds failed\n");
+        }
+
+        switch (sc.cmd) {
+        /* needs the flags argument translating from SDE kit to
+           linux */
+        case MTSP_SYSCALL_PIPEFREQ:
+                ret.retval = cpu_khz * 1000;
+                ret.errno = 0;
+                break;
+
+        case MTSP_SYSCALL_GETTOD:
+                memset(&tz, 0, sizeof(tz));
+                if ((ret.retval = sp_syscall(__NR_gettimeofday, (int)&tv,
+                                             (int)&tz, 0, 0)) == 0)
+                        ret.retval = tv.tv_sec;
+                break;
+
+        case MTSP_SYSCALL_EXIT:
+                list_for_each_entry(n, &kspd_notifylist, list)
+                        n->kspd_sp_exit(tclimit);
+                sp_stopping = 1;
+
+                printk(KERN_DEBUG "KSPD got exit syscall from SP exitcode %d\n",
+                       generic.arg0);
+                break;
+
+        case MTSP_SYSCALL_OPEN:
+                generic.arg1 = translate_open_flags(generic.arg1);
+
+                vcwd = vpe_getcwd(tclimit);
+
+                /* change to cwd of the process that loaded the SP program */
+                old_fs = get_fs();
+                set_fs(KERNEL_DS);
+                sys_chdir(vcwd);
+                set_fs(old_fs);
+
+                sc.cmd = __NR_open;
+
+                /* fall through */
+
+        default:
+                if ((sc.cmd >= __NR_Linux) &&
+                    (sc.cmd <= (__NR_Linux +  __NR_Linux_syscalls)) )
+                        cmd = sc.cmd;
+                else
+                        cmd = translate_syscall_command(sc.cmd);
+
+                if (cmd >= 0) {
+                        ret.retval = sp_syscall(cmd, generic.arg0, generic.arg1,
+                                                generic.arg2, generic.arg3);
+                } else
+                        printk(KERN_WARNING
+                               "KSPD: Unknown SP syscall number %d\n", sc.cmd);
+                break;
+        } /* switch */
+
+        if (vpe_getuid(tclimit)) {
+                err = sp_setfsuidgid(0, 0);
+                if (!err)
+                        pr_err("restoring old creds failed\n");
+        }
+
+        old_fs = get_fs();
+        set_fs(KERNEL_DS);
+        written = rtlx_write(RTLX_CHANNEL_SYSIO, &ret, sizeof(ret));
+        set_fs(old_fs);
+        if (written < sizeof(ret))
+                printk("KSPD: sp_work_handle_request failed to send to SP\n");
+}
+
+static void sp_cleanup(void)
+{
+        struct files_struct *files = current->files;
+        int i, j;
+        struct fdtable *fdt;
+
+        j = 0;
+
+        /*
+         * It is safe to dereference the fd table without RCU or
+         * ->file_lock
+         */
+        fdt = files_fdtable(files);
+        for (;;) {
+                unsigned long set;
+                i = j * __NFDBITS;
+                if (i >= fdt->max_fds)
+                        break;
+                set = fdt->open_fds->fds_bits[j++];
+                while (set) {
+                        if (set & 1) {
+                                struct file * file = xchg(&fdt->fd[i], NULL);
+                                if (file)
+                                        filp_close(file, files);
+                        }
+                        i++;
+                        set >>= 1;
+                }
+        }
+
+        /* Put daemon cwd back to root to avoid umount problems */
+        sys_chdir("/");
+}
+
+static int channel_open;
+
+/* the work handler */
+static void sp_work(struct work_struct *unused)
+{
+        if (!channel_open) {
+                if( rtlx_open(RTLX_CHANNEL_SYSIO, 1) != 0) {
+                        printk("KSPD: unable to open sp channel\n");
+                        sp_stopping = 1;
+                } else {
+                        channel_open++;
+                        printk(KERN_DEBUG "KSPD: SP channel opened\n");
+                }
+        } else {
+                /* wait for some data, allow it to sleep */
+                rtlx_read_poll(RTLX_CHANNEL_SYSIO, 1);
+
+                /* Check we haven't been woken because we are stopping */
+                if (!sp_stopping)
+                        sp_work_handle_request();
+        }
+
+        if (!sp_stopping)
+                queue_work(workqueue, &work);
+        else
+                sp_cleanup();
+}
+
+static void startwork(int vpe)
+{
+        sp_stopping = channel_open = 0;
+
+        if (workqueue == NULL) {
+                if ((workqueue = create_singlethread_workqueue("kspd")) == NULL) {
+                        printk(KERN_ERR "unable to start kspd\n");
+                        return;
+                }
+
+                INIT_WORK(&work, sp_work);
+        }
+
+        queue_work(workqueue, &work);
+}
+
+static void stopwork(int vpe)
+{
+        sp_stopping = 1;
+
+        printk(KERN_DEBUG "KSPD: SP stopping\n");
+}
+
+void kspd_notify(struct kspd_notifications *notify)
+{
+        list_add(&notify->list, &kspd_notifylist);
+}
+
+static struct vpe_notifications notify;
+static int kspd_module_init(void)
+{
+        INIT_LIST_HEAD(&kspd_notifylist);
+
+        notify.start = startwork;
+        notify.stop = stopwork;
+        vpe_notify(tclimit, &notify);
+
+        return 0;
+}
+
+static void kspd_module_exit(void)
+{
+
+}
+
+module_init(kspd_module_init);
+module_exit(kspd_module_exit);
+
+MODULE_DESCRIPTION("MIPS KSPD");
+MODULE_AUTHOR("Elizabeth Oldham, MIPS Technologies, Inc.");
+MODULE_LICENSE("GPL");