Added missing tegra files.HEADmaster

17 files changed, 1332 insertions, 0 deletions

diff --git a/arch/arm/mach-sa1100/dma.c b/arch/arm/mach-sa1100/dma.c
new file mode 100644
index 00000000000..ad660350c29
--- /dev/null
+++ b/arch/arm/mach-sa1100/dma.c
@@ -0,0 +1,348 @@
+/*
+ * arch/arm/mach-sa1100/dma.c
+ *
+ * Support functions for the SA11x0 internal DMA channels.
+ *
+ * Copyright (C) 2000, 2001 by Nicolas Pitre
+ *
+ * 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/interrupt.h>
+#include <linux/init.h>
+#include <linux/spinlock.h>
+#include <linux/errno.h>
+
+#include <asm/system.h>
+#include <asm/irq.h>
+#include <mach/hardware.h>
+#include <mach/dma.h>
+
+
+#undef DEBUG
+#ifdef DEBUG
+#define DPRINTK( s, arg... )  printk( "dma<%p>: " s, regs , ##arg )
+#else
+#define DPRINTK( x... )
+#endif
+
+
+typedef struct {
+        const char *device_id;          /* device name */
+        u_long device;                  /* this channel device, 0  if unused*/
+        dma_callback_t callback;        /* to call when DMA completes */
+        void *data;                     /* ... with private data ptr */
+} sa1100_dma_t;
+
+static sa1100_dma_t dma_chan[SA1100_DMA_CHANNELS];
+
+static DEFINE_SPINLOCK(dma_list_lock);
+
+
+static irqreturn_t dma_irq_handler(int irq, void *dev_id)
+{
+        dma_regs_t *dma_regs = dev_id;
+        sa1100_dma_t *dma = dma_chan + (((u_int)dma_regs >> 5) & 7);
+        int status = dma_regs->RdDCSR;
+
+        if (status & (DCSR_ERROR)) {
+                printk(KERN_CRIT "DMA on \"%s\" caused an error\n", dma->device_id);
+                dma_regs->ClrDCSR = DCSR_ERROR;
+        }
+
+        dma_regs->ClrDCSR = status & (DCSR_DONEA | DCSR_DONEB);
+        if (dma->callback) {
+                if (status & DCSR_DONEA)
+                        dma->callback(dma->data);
+                if (status & DCSR_DONEB)
+                        dma->callback(dma->data);
+        }
+        return IRQ_HANDLED;
+}
+
+
+/**
+ *      sa1100_request_dma - allocate one of the SA11x0's DMA channels
+ *      @device: The SA11x0 peripheral targeted by this request
+ *      @device_id: An ascii name for the claiming device
+ *      @callback: Function to be called when the DMA completes
+ *      @data: A cookie passed back to the callback function
+ *      @dma_regs: Pointer to the location of the allocated channel's identifier
+ *
+ *      This function will search for a free DMA channel and returns the
+ *      address of the hardware registers for that channel as the channel
+ *      identifier. This identifier is written to the location pointed by
+ *      @dma_regs. The list of possible values for @device are listed into
+ *      arch/arm/mach-sa1100/include/mach/dma.h as a dma_device_t enum.
+ *
+ *      Note that reading from a port and writing to the same port are
+ *      actually considered as two different streams requiring separate
+ *      DMA registrations.
+ *
+ *      The @callback function is called from interrupt context when one
+ *      of the two possible DMA buffers in flight has terminated. That
+ *      function has to be small and efficient while posponing more complex
+ *      processing to a lower priority execution context.
+ *
+ *      If no channels are available, or if the desired @device is already in
+ *      use by another DMA channel, then an error code is returned.  This
+ *      function must be called before any other DMA calls.
+ **/
+
+int sa1100_request_dma (dma_device_t device, const char *device_id,
+                        dma_callback_t callback, void *data,
+                        dma_regs_t **dma_regs)
+{
+        sa1100_dma_t *dma = NULL;
+        dma_regs_t *regs;
+        int i, err;
+
+        *dma_regs = NULL;
+
+        err = 0;
+        spin_lock(&dma_list_lock);
+        for (i = 0; i < SA1100_DMA_CHANNELS; i++) {
+                if (dma_chan[i].device == device) {
+                        err = -EBUSY;
+                        break;
+                } else if (!dma_chan[i].device && !dma) {
+                        dma = &dma_chan[i];
+                }
+        }
+        if (!err) {
+                if (dma)
+                        dma->device = device;
+                else
+                        err = -ENOSR;
+        }
+        spin_unlock(&dma_list_lock);
+        if (err)
+                return err;
+
+        i = dma - dma_chan;
+        regs = (dma_regs_t *)&DDAR(i);
+        err = request_irq(IRQ_DMA0 + i, dma_irq_handler, IRQF_DISABLED,
+                          device_id, regs);
+        if (err) {
+                printk(KERN_ERR
+                       "%s: unable to request IRQ %d for %s\n",
+                       __func__, IRQ_DMA0 + i, device_id);
+                dma->device = 0;
+                return err;
+        }
+
+        *dma_regs = regs;
+        dma->device_id = device_id;
+        dma->callback = callback;
+        dma->data = data;
+
+        regs->ClrDCSR =
+                (DCSR_DONEA | DCSR_DONEB | DCSR_STRTA | DCSR_STRTB |
+                 DCSR_IE | DCSR_ERROR | DCSR_RUN);
+        regs->DDAR = device;
+
+        return 0;
+}
+
+
+/**
+ *      sa1100_free_dma - free a SA11x0 DMA channel
+ *      @regs: identifier for the channel to free
+ *
+ *      This clears all activities on a given DMA channel and releases it
+ *      for future requests.  The @regs identifier is provided by a
+ *      successful call to sa1100_request_dma().
+ **/
+
+void sa1100_free_dma(dma_regs_t *regs)
+{
+        int i;
+
+        for (i = 0; i < SA1100_DMA_CHANNELS; i++)
+                if (regs == (dma_regs_t *)&DDAR(i))
+                        break;
+        if (i >= SA1100_DMA_CHANNELS) {
+                printk(KERN_ERR "%s: bad DMA identifier\n", __func__);
+                return;
+        }
+
+        if (!dma_chan[i].device) {
+                printk(KERN_ERR "%s: Trying to free free DMA\n", __func__);
+                return;
+        }
+
+        regs->ClrDCSR =
+                (DCSR_DONEA | DCSR_DONEB | DCSR_STRTA | DCSR_STRTB |
+                 DCSR_IE | DCSR_ERROR | DCSR_RUN);
+        free_irq(IRQ_DMA0 + i, regs);
+        dma_chan[i].device = 0;
+}
+
+
+/**
+ *      sa1100_start_dma - submit a data buffer for DMA
+ *      @regs: identifier for the channel to use
+ *      @dma_ptr: buffer physical (or bus) start address
+ *      @size: buffer size
+ *
+ *      This function hands the given data buffer to the hardware for DMA
+ *      access. If another buffer is already in flight then this buffer
+ *      will be queued so the DMA engine will switch to it automatically
+ *      when the previous one is done.  The DMA engine is actually toggling
+ *      between two buffers so at most 2 successful calls can be made before
+ *      one of them terminates and the callback function is called.
+ *
+ *      The @regs identifier is provided by a successful call to
+ *      sa1100_request_dma().
+ *
+ *      The @size must not be larger than %MAX_DMA_SIZE.  If a given buffer
+ *      is larger than that then it's the caller's responsibility to split
+ *      it into smaller chunks and submit them separately. If this is the
+ *      case then a @size of %CUT_DMA_SIZE is recommended to avoid ending
+ *      up with too small chunks. The callback function can be used to chain
+ *      submissions of buffer chunks.
+ *
+ *      Error return values:
+ *      %-EOVERFLOW:    Given buffer size is too big.
+ *      %-EBUSY:        Both DMA buffers are already in use.
+ *      %-EAGAIN:       Both buffers were busy but one of them just completed
+ *                      but the interrupt handler has to execute first.
+ *
+ *      This function returs 0 on success.
+ **/
+
+int sa1100_start_dma(dma_regs_t *regs, dma_addr_t dma_ptr, u_int size)
+{
+        unsigned long flags;
+        u_long status;
+        int ret;
+
+        if (dma_ptr & 3)
+                printk(KERN_WARNING "DMA: unaligned start address (0x%08lx)\n",
+                       (unsigned long)dma_ptr);
+
+        if (size > MAX_DMA_SIZE)
+                return -EOVERFLOW;
+
+        local_irq_save(flags);
+        status = regs->RdDCSR;
+
+        /* If both DMA buffers are started, there's nothing else we can do. */
+        if ((status & (DCSR_STRTA | DCSR_STRTB)) == (DCSR_STRTA | DCSR_STRTB)) {
+                DPRINTK("start: st %#x busy\n", status);
+                ret = -EBUSY;
+                goto out;
+        }
+
+        if (((status & DCSR_BIU) && (status & DCSR_STRTB)) ||
+            (!(status & DCSR_BIU) && !(status & DCSR_STRTA))) {
+                if (status & DCSR_DONEA) {
+                        /* give a chance for the interrupt to be processed */
+                        ret = -EAGAIN;
+                        goto out;
+                }
+                regs->DBSA = dma_ptr;
+                regs->DBTA = size;
+                regs->SetDCSR = DCSR_STRTA | DCSR_IE | DCSR_RUN;
+                DPRINTK("start a=%#x s=%d on A\n", dma_ptr, size);
+        } else {
+                if (status & DCSR_DONEB) {
+                        /* give a chance for the interrupt to be processed */
+                        ret = -EAGAIN;
+                        goto out;
+                }
+                regs->DBSB = dma_ptr;
+                regs->DBTB = size;
+                regs->SetDCSR = DCSR_STRTB | DCSR_IE | DCSR_RUN;
+                DPRINTK("start a=%#x s=%d on B\n", dma_ptr, size);
+        }
+        ret = 0;
+
+out:
+        local_irq_restore(flags);
+        return ret;
+}
+
+
+/**
+ *      sa1100_get_dma_pos - return current DMA position
+ *      @regs: identifier for the channel to use
+ *
+ *      This function returns the current physical (or bus) address for the
+ *      given DMA channel.  If the channel is running i.e. not in a stopped
+ *      state then the caller must disable interrupts prior calling this
+ *      function and process the returned value before re-enabling them to
+ *      prevent races with the completion interrupt handler and the callback
+ *      function. The validation of the returned value is the caller's
+ *      responsibility as well -- the hardware seems to return out of range
+ *      values when the DMA engine completes a buffer.
+ *
+ *      The @regs identifier is provided by a successful call to
+ *      sa1100_request_dma().
+ **/
+
+dma_addr_t sa1100_get_dma_pos(dma_regs_t *regs)
+{
+        int status;
+
+        /*
+         * We must determine whether buffer A or B is active.
+         * Two possibilities: either we are in the middle of
+         * a buffer, or the DMA controller just switched to the
+         * next toggle but the interrupt hasn't been serviced yet.
+         * The former case is straight forward.  In the later case,
+         * we'll do like if DMA is just at the end of the previous
+         * toggle since all registers haven't been reset yet.
+         * This goes around the edge case and since we're always
+         * a little behind anyways it shouldn't make a big difference.
+         * If DMA has been stopped prior calling this then the
+         * position is exact.
+         */
+        status = regs->RdDCSR;
+        if ((!(status & DCSR_BIU) &&  (status & DCSR_STRTA)) ||
+            ( (status & DCSR_BIU) && !(status & DCSR_STRTB)))
+                return regs->DBSA;
+        else
+                return regs->DBSB;
+}
+
+
+/**
+ *      sa1100_reset_dma - reset a DMA channel
+ *      @regs: identifier for the channel to use
+ *
+ *      This function resets and reconfigure the given DMA channel. This is
+ *      particularly useful after a sleep/wakeup event.
+ *
+ *      The @regs identifier is provided by a successful call to
+ *      sa1100_request_dma().
+ **/
+
+void sa1100_reset_dma(dma_regs_t *regs)
+{
+        int i;
+
+        for (i = 0; i < SA1100_DMA_CHANNELS; i++)
+                if (regs == (dma_regs_t *)&DDAR(i))
+                        break;
+        if (i >= SA1100_DMA_CHANNELS) {
+                printk(KERN_ERR "%s: bad DMA identifier\n", __func__);
+                return;
+        }
+
+        regs->ClrDCSR =
+                (DCSR_DONEA | DCSR_DONEB | DCSR_STRTA | DCSR_STRTB |
+                 DCSR_IE | DCSR_ERROR | DCSR_RUN);
+        regs->DDAR = dma_chan[i].device;
+}
+
+
+EXPORT_SYMBOL(sa1100_request_dma);
+EXPORT_SYMBOL(sa1100_free_dma);
+EXPORT_SYMBOL(sa1100_start_dma);
+EXPORT_SYMBOL(sa1100_get_dma_pos);
+EXPORT_SYMBOL(sa1100_reset_dma);
+
diff --git a/arch/arm/mach-sa1100/gpio.c b/arch/arm/mach-sa1100/gpio.c
new file mode 100644
index 00000000000..0d3829a8c2c
--- /dev/null
+++ b/arch/arm/mach-sa1100/gpio.c
@@ -0,0 +1,65 @@
+/*
+ * linux/arch/arm/mach-sa1100/gpio.c
+ *
+ * Generic SA-1100 GPIO handling
+ *
+ * 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/init.h>
+#include <linux/module.h>
+
+#include <asm/gpio.h>
+#include <mach/hardware.h>
+#include "generic.h"
+
+static int sa1100_gpio_get(struct gpio_chip *chip, unsigned offset)
+{
+        return GPLR & GPIO_GPIO(offset);
+}
+
+static void sa1100_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
+{
+        if (value)
+                GPSR = GPIO_GPIO(offset);
+        else
+                GPCR = GPIO_GPIO(offset);
+}
+
+static int sa1100_direction_input(struct gpio_chip *chip, unsigned offset)
+{
+        unsigned long flags;
+
+        local_irq_save(flags);
+        GPDR &= ~GPIO_GPIO(offset);
+        local_irq_restore(flags);
+        return 0;
+}
+
+static int sa1100_direction_output(struct gpio_chip *chip, unsigned offset, int value)
+{
+        unsigned long flags;
+
+        local_irq_save(flags);
+        sa1100_gpio_set(chip, offset, value);
+        GPDR |= GPIO_GPIO(offset);
+        local_irq_restore(flags);
+        return 0;
+}
+
+static struct gpio_chip sa1100_gpio_chip = {
+        .label                  = "gpio",
+        .direction_input        = sa1100_direction_input,
+        .direction_output       = sa1100_direction_output,
+        .set                    = sa1100_gpio_set,
+        .get                    = sa1100_gpio_get,
+        .base                   = 0,
+        .ngpio                  = GPIO_MAX + 1,
+};
+
+void __init sa1100_init_gpio(void)
+{
+        gpiochip_add(&sa1100_gpio_chip);
+}
diff --git a/arch/arm/mach-sa1100/include/mach/SA-1111.h b/arch/arm/mach-sa1100/include/mach/SA-1111.h
new file mode 100644
index 00000000000..c38f60915cb
--- /dev/null
+++ b/arch/arm/mach-sa1100/include/mach/SA-1111.h
@@ -0,0 +1,5 @@
+/*
+ * Moved to new location
+ */
+#warning using old SA-1111.h - update to <asm/hardware/sa1111.h>
+#include <asm/hardware/sa1111.h>
diff --git a/arch/arm/mach-sa1100/include/mach/dma.h b/arch/arm/mach-sa1100/include/mach/dma.h
new file mode 100644
index 00000000000..dda1b351310
--- /dev/null
+++ b/arch/arm/mach-sa1100/include/mach/dma.h
@@ -0,0 +1,117 @@
+/*
+ * arch/arm/mach-sa1100/include/mach/dma.h
+ *
+ * Generic SA1100 DMA support
+ *
+ * Copyright (C) 2000 Nicolas Pitre
+ *
+ */
+
+#ifndef __ASM_ARCH_DMA_H
+#define __ASM_ARCH_DMA_H
+
+#include "hardware.h"
+
+
+/*
+ * The SA1100 has six internal DMA channels.
+ */
+#define SA1100_DMA_CHANNELS     6
+
+/*
+ * Maximum physical DMA buffer size
+ */
+#define MAX_DMA_SIZE            0x1fff
+#define CUT_DMA_SIZE            0x1000
+
+/*
+ * All possible SA1100 devices a DMA channel can be attached to.
+ */
+typedef enum {
+        DMA_Ser0UDCWr  = DDAR_Ser0UDCWr,   /* Ser. port 0 UDC Write */
+        DMA_Ser0UDCRd  = DDAR_Ser0UDCRd,   /* Ser. port 0 UDC Read */
+        DMA_Ser1UARTWr = DDAR_Ser1UARTWr,  /* Ser. port 1 UART Write */
+        DMA_Ser1UARTRd = DDAR_Ser1UARTRd,  /* Ser. port 1 UART Read */
+        DMA_Ser1SDLCWr = DDAR_Ser1SDLCWr,  /* Ser. port 1 SDLC Write */
+        DMA_Ser1SDLCRd = DDAR_Ser1SDLCRd,  /* Ser. port 1 SDLC Read */
+        DMA_Ser2UARTWr = DDAR_Ser2UARTWr,  /* Ser. port 2 UART Write */
+        DMA_Ser2UARTRd = DDAR_Ser2UARTRd,  /* Ser. port 2 UART Read */
+        DMA_Ser2HSSPWr = DDAR_Ser2HSSPWr,  /* Ser. port 2 HSSP Write */
+        DMA_Ser2HSSPRd = DDAR_Ser2HSSPRd,  /* Ser. port 2 HSSP Read */
+        DMA_Ser3UARTWr = DDAR_Ser3UARTWr,  /* Ser. port 3 UART Write */
+        DMA_Ser3UARTRd = DDAR_Ser3UARTRd,  /* Ser. port 3 UART Read */
+        DMA_Ser4MCP0Wr = DDAR_Ser4MCP0Wr,  /* Ser. port 4 MCP 0 Write (audio) */
+        DMA_Ser4MCP0Rd = DDAR_Ser4MCP0Rd,  /* Ser. port 4 MCP 0 Read (audio) */
+        DMA_Ser4MCP1Wr = DDAR_Ser4MCP1Wr,  /* Ser. port 4 MCP 1 Write */
+        DMA_Ser4MCP1Rd = DDAR_Ser4MCP1Rd,  /* Ser. port 4 MCP 1 Read */
+        DMA_Ser4SSPWr  = DDAR_Ser4SSPWr,   /* Ser. port 4 SSP Write (16 bits) */
+        DMA_Ser4SSPRd  = DDAR_Ser4SSPRd    /* Ser. port 4 SSP Read (16 bits) */
+} dma_device_t;
+
+typedef struct {
+        volatile u_long DDAR;
+        volatile u_long SetDCSR;
+        volatile u_long ClrDCSR;
+        volatile u_long RdDCSR;
+        volatile dma_addr_t DBSA;
+        volatile u_long DBTA;
+        volatile dma_addr_t DBSB;
+        volatile u_long DBTB;
+} dma_regs_t;
+
+typedef void (*dma_callback_t)(void *data);
+
+/*
+ * DMA function prototypes
+ */
+
+extern int sa1100_request_dma( dma_device_t device, const char *device_id,
+                               dma_callback_t callback, void *data,
+                               dma_regs_t **regs );
+extern void sa1100_free_dma( dma_regs_t *regs );
+extern int sa1100_start_dma( dma_regs_t *regs, dma_addr_t dma_ptr, u_int size );
+extern dma_addr_t sa1100_get_dma_pos(dma_regs_t *regs);
+extern void sa1100_reset_dma(dma_regs_t *regs);
+
+/**
+ *      sa1100_stop_dma - stop DMA in progress
+ *      @regs: identifier for the channel to use
+ *
+ *      This stops DMA without clearing buffer pointers. Unlike
+ *      sa1100_clear_dma() this allows subsequent use of sa1100_resume_dma()
+ *      or sa1100_get_dma_pos().
+ *
+ *      The @regs identifier is provided by a successful call to
+ *      sa1100_request_dma().
+ **/
+
+#define sa1100_stop_dma(regs)   ((regs)->ClrDCSR = DCSR_IE|DCSR_RUN)
+
+/**
+ *      sa1100_resume_dma - resume DMA on a stopped channel
+ *      @regs: identifier for the channel to use
+ *
+ *      This resumes DMA on a channel previously stopped with
+ *      sa1100_stop_dma().
+ *
+ *      The @regs identifier is provided by a successful call to
+ *      sa1100_request_dma().
+ **/
+
+#define sa1100_resume_dma(regs) ((regs)->SetDCSR = DCSR_IE|DCSR_RUN)
+
+/**
+ *      sa1100_clear_dma - clear DMA pointers
+ *      @regs: identifier for the channel to use
+ *
+ *      This clear any DMA state so the DMA engine is ready to restart
+ *      with new buffers through sa1100_start_dma(). Any buffers in flight
+ *      are discarded.
+ *
+ *      The @regs identifier is provided by a successful call to
+ *      sa1100_request_dma().
+ **/
+
+#define sa1100_clear_dma(regs)  ((regs)->ClrDCSR = DCSR_IE|DCSR_RUN|DCSR_STRTA|DCSR_STRTB)
+
+#endif /* _ASM_ARCH_DMA_H */
diff --git a/arch/arm/mach-sa1100/include/mach/io.h b/arch/arm/mach-sa1100/include/mach/io.h
new file mode 100644
index 00000000000..d8b43f3dcd2
--- /dev/null
+++ b/arch/arm/mach-sa1100/include/mach/io.h
@@ -0,0 +1,22 @@
+/*
+ * arch/arm/mach-sa1100/include/mach/io.h
+ *
+ * Copyright (C) 1997-1999 Russell King
+ *
+ * Modifications:
+ *  06-12-1997  RMK     Created.
+ *  07-04-1999  RMK     Major cleanup
+ */
+#ifndef __ASM_ARM_ARCH_IO_H
+#define __ASM_ARM_ARCH_IO_H
+
+#define IO_SPACE_LIMIT 0xffffffff
+
+/*
+ * We don't actually have real ISA nor PCI buses, but there is so many 
+ * drivers out there that might just work if we fake them...
+ */
+#define __io(a)         __typesafe_io(a)
+#define __mem_pci(a)    (a)
+
+#endif
diff --git a/arch/arm/mach-sa1100/include/mach/lart.h b/arch/arm/mach-sa1100/include/mach/lart.h
new file mode 100644
index 00000000000..8a5482d908d
--- /dev/null
+++ b/arch/arm/mach-sa1100/include/mach/lart.h
@@ -0,0 +1,13 @@
+#ifndef _INCLUDE_LART_H
+#define _INCLUDE_LART_H
+
+#define LART_GPIO_ETH0                  GPIO_GPIO0
+#define LART_IRQ_ETH0                   IRQ_GPIO0
+
+#define LART_GPIO_IDE                   GPIO_GPIO1
+#define LART_IRQ_IDE                    IRQ_GPIO1
+
+#define LART_GPIO_UCB1200               GPIO_GPIO18
+#define LART_IRQ_UCB1200                IRQ_GPIO18
+
+#endif
diff --git a/arch/arm/mach-sa1100/include/mach/mcp.h b/arch/arm/mach-sa1100/include/mach/mcp.h
new file mode 100644
index 00000000000..ed1a331508a
--- /dev/null
+++ b/arch/arm/mach-sa1100/include/mach/mcp.h
@@ -0,0 +1,22 @@
+/*
+ *  arch/arm/mach-sa1100/include/mach/mcp.h
+ *
+ *  Copyright (C) 2005 Russell King.
+ *
+ * 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.
+ */
+#ifndef __ASM_ARM_ARCH_MCP_H
+#define __ASM_ARM_ARCH_MCP_H
+
+#include <linux/types.h>
+
+struct mcp_plat_data {
+        u32 mccr0;
+        u32 mccr1;
+        unsigned int sclk_rate;
+        int gpio_base;
+};
+
+#endif
diff --git a/arch/arm/mach-sa1100/include/mach/system.h b/arch/arm/mach-sa1100/include/mach/system.h
new file mode 100644
index 00000000000..ba9da9f7f18
--- /dev/null
+++ b/arch/arm/mach-sa1100/include/mach/system.h
@@ -0,0 +1,22 @@
+/*
+ * arch/arm/mach-sa1100/include/mach/system.h
+ *
+ * Copyright (c) 1999 Nicolas Pitre <nico@fluxnic.net>
+ */
+#include <mach/hardware.h>
+
+static inline void arch_idle(void)
+{
+        cpu_do_idle();
+}
+
+static inline void arch_reset(char mode, const char *cmd)
+{
+        if (mode == 's') {
+                /* Jump into ROM at address 0 */
+                cpu_reset(0);
+        } else {
+                /* Use on-chip reset capability */
+                RSRR = RSRR_SWR;
+        }
+}
diff --git a/arch/arm/mach-sa1100/include/mach/vmalloc.h b/arch/arm/mach-sa1100/include/mach/vmalloc.h
new file mode 100644
index 00000000000..b3d00239848
--- /dev/null
+++ b/arch/arm/mach-sa1100/include/mach/vmalloc.h
@@ -0,0 +1,4 @@
+/*
+ * arch/arm/mach-sa1100/include/mach/vmalloc.h
+ */
+#define VMALLOC_END       (0xe8000000UL)
diff --git a/arch/arm/mach-sa1100/leds-assabet.c b/arch/arm/mach-sa1100/leds-assabet.c
new file mode 100644
index 00000000000..64e9b4b11b5
--- /dev/null
+++ b/arch/arm/mach-sa1100/leds-assabet.c
@@ -0,0 +1,114 @@
+/*
+ * linux/arch/arm/mach-sa1100/leds-assabet.c
+ *
+ * Copyright (C) 2000 John Dorsey <john+@cs.cmu.edu>
+ *
+ * Original (leds-footbridge.c) by Russell King
+ *
+ * Assabet uses the LEDs as follows:
+ *   - Green - toggles state every 50 timer interrupts
+ *   - Red   - on if system is not idle
+ */
+#include <linux/init.h>
+
+#include <mach/hardware.h>
+#include <asm/leds.h>
+#include <asm/system.h>
+#include <mach/assabet.h>
+
+#include "leds.h"
+
+
+#define LED_STATE_ENABLED       1
+#define LED_STATE_CLAIMED       2
+
+static unsigned int led_state;
+static unsigned int hw_led_state;
+
+#define ASSABET_BCR_LED_MASK    (ASSABET_BCR_LED_GREEN | ASSABET_BCR_LED_RED)
+
+void assabet_leds_event(led_event_t evt)
+{
+        unsigned long flags;
+
+        local_irq_save(flags);
+
+        switch (evt) {
+        case led_start:
+                hw_led_state = ASSABET_BCR_LED_RED | ASSABET_BCR_LED_GREEN;
+                led_state = LED_STATE_ENABLED;
+                break;
+
+        case led_stop:
+                led_state &= ~LED_STATE_ENABLED;
+                hw_led_state = ASSABET_BCR_LED_RED | ASSABET_BCR_LED_GREEN;
+                ASSABET_BCR_frob(ASSABET_BCR_LED_MASK, hw_led_state);
+                break;
+
+        case led_claim:
+                led_state |= LED_STATE_CLAIMED;
+                hw_led_state = ASSABET_BCR_LED_RED | ASSABET_BCR_LED_GREEN;
+                break;
+
+        case led_release:
+                led_state &= ~LED_STATE_CLAIMED;
+                hw_led_state = ASSABET_BCR_LED_RED | ASSABET_BCR_LED_GREEN;
+                break;
+
+#ifdef CONFIG_LEDS_TIMER
+        case led_timer:
+                if (!(led_state & LED_STATE_CLAIMED))
+                        hw_led_state ^= ASSABET_BCR_LED_GREEN;
+                break;
+#endif
+
+#ifdef CONFIG_LEDS_CPU
+        case led_idle_start:
+                if (!(led_state & LED_STATE_CLAIMED))
+                        hw_led_state |= ASSABET_BCR_LED_RED;
+                break;
+
+        case led_idle_end:
+                if (!(led_state & LED_STATE_CLAIMED))
+                        hw_led_state &= ~ASSABET_BCR_LED_RED;
+                break;
+#endif
+
+        case led_halted:
+                break;
+
+        case led_green_on:
+                if (led_state & LED_STATE_CLAIMED)
+                        hw_led_state &= ~ASSABET_BCR_LED_GREEN;
+                break;
+
+        case led_green_off:
+                if (led_state & LED_STATE_CLAIMED)
+                        hw_led_state |= ASSABET_BCR_LED_GREEN;
+                break;
+
+        case led_amber_on:
+                break;
+
+        case led_amber_off:
+                break;
+
+        case led_red_on:
+                if (led_state & LED_STATE_CLAIMED)
+                        hw_led_state &= ~ASSABET_BCR_LED_RED;
+                break;
+
+        case led_red_off:
+                if (led_state & LED_STATE_CLAIMED)
+                        hw_led_state |= ASSABET_BCR_LED_RED;
+                break;
+
+        default:
+                break;
+        }
+
+        if  (led_state & LED_STATE_ENABLED)
+                ASSABET_BCR_frob(ASSABET_BCR_LED_MASK, hw_led_state);
+
+        local_irq_restore(flags);
+}
diff --git a/arch/arm/mach-sa1100/leds-badge4.c b/arch/arm/mach-sa1100/leds-badge4.c
new file mode 100644
index 00000000000..cf1e38458b8
--- /dev/null
+++ b/arch/arm/mach-sa1100/leds-badge4.c
@@ -0,0 +1,111 @@
+/*
+ * linux/arch/arm/mach-sa1100/leds-badge4.c
+ *
+ * Author: Christopher Hoover <ch@hpl.hp.com>
+ * Copyright (C) 2002 Hewlett-Packard Company
+ *
+ * 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/init.h>
+
+#include <mach/hardware.h>
+#include <asm/leds.h>
+#include <asm/system.h>
+
+#include "leds.h"
+
+#define LED_STATE_ENABLED       1
+#define LED_STATE_CLAIMED       2
+
+static unsigned int led_state;
+static unsigned int hw_led_state;
+
+#define LED_RED         GPIO_GPIO(7)
+#define LED_GREEN       GPIO_GPIO(9)
+#define LED_MASK        (LED_RED|LED_GREEN)
+
+#define LED_IDLE        LED_GREEN
+#define LED_TIMER       LED_RED
+
+void badge4_leds_event(led_event_t evt)
+{
+        unsigned long flags;
+
+        local_irq_save(flags);
+
+        switch (evt) {
+        case led_start:
+                GPDR |= LED_MASK;
+                hw_led_state = LED_MASK;
+                led_state = LED_STATE_ENABLED;
+                break;
+
+        case led_stop:
+                led_state &= ~LED_STATE_ENABLED;
+                break;
+
+        case led_claim:
+                led_state |= LED_STATE_CLAIMED;
+                hw_led_state = LED_MASK;
+                break;
+
+        case led_release:
+                led_state &= ~LED_STATE_CLAIMED;
+                hw_led_state = LED_MASK;
+                break;
+
+#ifdef CONFIG_LEDS_TIMER
+        case led_timer:
+                if (!(led_state & LED_STATE_CLAIMED))
+                        hw_led_state ^= LED_TIMER;
+                break;
+#endif
+
+#ifdef CONFIG_LEDS_CPU
+        case led_idle_start:
+                /* LED off when system is idle */
+                if (!(led_state & LED_STATE_CLAIMED))
+                        hw_led_state &= ~LED_IDLE;
+                break;
+
+        case led_idle_end:
+                if (!(led_state & LED_STATE_CLAIMED))
+                        hw_led_state |= LED_IDLE;
+                break;
+#endif
+
+        case led_red_on:
+                if (!(led_state & LED_STATE_CLAIMED))
+                        hw_led_state &= ~LED_RED;
+                break;
+
+        case led_red_off:
+                if (!(led_state & LED_STATE_CLAIMED))
+                        hw_led_state |= LED_RED;
+                break;
+
+        case led_green_on:
+                if (!(led_state & LED_STATE_CLAIMED))
+                        hw_led_state &= ~LED_GREEN;
+                break;
+
+        case led_green_off:
+                if (!(led_state & LED_STATE_CLAIMED))
+                        hw_led_state |= LED_GREEN;
+                break;
+
+        default:
+                break;
+        }
+
+        if  (led_state & LED_STATE_ENABLED) {
+                GPSR = hw_led_state;
+                GPCR = hw_led_state ^ LED_MASK;
+        }
+
+        local_irq_restore(flags);
+}
diff --git a/arch/arm/mach-sa1100/leds-cerf.c b/arch/arm/mach-sa1100/leds-cerf.c
new file mode 100644
index 00000000000..259b48e0be8
--- /dev/null
+++ b/arch/arm/mach-sa1100/leds-cerf.c
@@ -0,0 +1,110 @@
+/*
+ * linux/arch/arm/mach-sa1100/leds-cerf.c
+ *
+ * Author: ???
+ */
+#include <linux/init.h>
+
+#include <mach/hardware.h>
+#include <asm/leds.h>
+#include <asm/system.h>
+
+#include "leds.h"
+
+
+#define LED_STATE_ENABLED       1
+#define LED_STATE_CLAIMED       2
+
+static unsigned int led_state;
+static unsigned int hw_led_state;
+
+#define LED_D0          GPIO_GPIO(0)
+#define LED_D1          GPIO_GPIO(1)
+#define LED_D2          GPIO_GPIO(2)
+#define LED_D3          GPIO_GPIO(3)
+#define LED_MASK        (LED_D0|LED_D1|LED_D2|LED_D3)
+
+void cerf_leds_event(led_event_t evt)
+{
+        unsigned long flags;
+
+        local_irq_save(flags);
+
+        switch (evt) {
+        case led_start:
+                hw_led_state = LED_MASK;
+                led_state = LED_STATE_ENABLED;
+                break;
+
+        case led_stop:
+                led_state &= ~LED_STATE_ENABLED;
+                break;
+
+        case led_claim:
+                led_state |= LED_STATE_CLAIMED;
+                hw_led_state = LED_MASK;
+                break;
+        case led_release:
+                led_state &= ~LED_STATE_CLAIMED;
+                hw_led_state = LED_MASK;
+                break;
+
+#ifdef CONFIG_LEDS_TIMER
+        case led_timer:
+                if (!(led_state & LED_STATE_CLAIMED))
+                        hw_led_state ^= LED_D0;
+                break;
+#endif
+
+#ifdef CONFIG_LEDS_CPU
+        case led_idle_start:
+                if (!(led_state & LED_STATE_CLAIMED))
+                        hw_led_state &= ~LED_D1;
+                break;
+
+        case led_idle_end:
+                if (!(led_state & LED_STATE_CLAIMED))
+                        hw_led_state |= LED_D1;
+                break;
+#endif
+        case led_green_on:
+                if (!(led_state & LED_STATE_CLAIMED))
+                        hw_led_state &= ~LED_D2;
+                break;
+
+        case led_green_off:
+                if (!(led_state & LED_STATE_CLAIMED))
+                        hw_led_state |= LED_D2;
+                break;
+
+        case led_amber_on:
+                if (!(led_state & LED_STATE_CLAIMED))
+                        hw_led_state &= ~LED_D3;
+                break;
+
+        case led_amber_off:
+                if (!(led_state & LED_STATE_CLAIMED))
+                        hw_led_state |= LED_D3;
+                break;
+
+        case led_red_on:
+                if (!(led_state & LED_STATE_CLAIMED))
+                        hw_led_state &= ~LED_D1;
+                break;
+
+        case led_red_off:
+                if (!(led_state & LED_STATE_CLAIMED))
+                        hw_led_state |= LED_D1;
+                break;
+
+        default:
+                break;
+        }
+
+        if  (led_state & LED_STATE_ENABLED) {
+                GPSR = hw_led_state;
+                GPCR = hw_led_state ^ LED_MASK;
+        }
+
+        local_irq_restore(flags);
+}
diff --git a/arch/arm/mach-sa1100/leds-hackkit.c b/arch/arm/mach-sa1100/leds-hackkit.c
new file mode 100644
index 00000000000..2bce137462e
--- /dev/null
+++ b/arch/arm/mach-sa1100/leds-hackkit.c
@@ -0,0 +1,112 @@
+/*
+ * linux/arch/arm/mach-sa1100/leds-hackkit.c
+ *
+ * based on leds-lart.c
+ *
+ * (C) Erik Mouw (J.A.K.Mouw@its.tudelft.nl), April 21, 2000
+ * (C) Stefan Eletzhofer <stefan.eletzhofer@eletztrick.de>, 2002
+ *
+ * The HackKit has two leds (GPIO 22/23). The red led (gpio 22) is used
+ * as cpu led, the green one is used as timer led.
+ */
+#include <linux/init.h>
+
+#include <mach/hardware.h>
+#include <asm/leds.h>
+#include <asm/system.h>
+
+#include "leds.h"
+
+
+#define LED_STATE_ENABLED       1
+#define LED_STATE_CLAIMED       2
+
+static unsigned int led_state;
+static unsigned int hw_led_state;
+
+#define LED_GREEN    GPIO_GPIO23
+#define LED_RED    GPIO_GPIO22
+#define LED_MASK  (LED_RED | LED_GREEN)
+
+void hackkit_leds_event(led_event_t evt)
+{
+        unsigned long flags;
+
+        local_irq_save(flags);
+
+        switch(evt) {
+                case led_start:
+                        /* pin 22/23 are outputs */
+                        GPDR |= LED_MASK;
+                        hw_led_state = LED_MASK;
+                        led_state = LED_STATE_ENABLED;
+                        break;
+
+                case led_stop:
+                        led_state &= ~LED_STATE_ENABLED;
+                        break;
+
+                case led_claim:
+                        led_state |= LED_STATE_CLAIMED;
+                        hw_led_state = LED_MASK;
+                        break;
+
+                case led_release:
+                        led_state &= ~LED_STATE_CLAIMED;
+                        hw_led_state = LED_MASK;
+                        break;
+
+#ifdef CONFIG_LEDS_TIMER
+                case led_timer:
+                        if (!(led_state & LED_STATE_CLAIMED))
+                                hw_led_state ^= LED_GREEN;
+                        break;
+#endif
+
+#ifdef CONFIG_LEDS_CPU
+                case led_idle_start:
+                        /* The LART people like the LED to be off when the
+                           system is idle... */
+                        if (!(led_state & LED_STATE_CLAIMED))
+                                hw_led_state &= ~LED_RED;
+                        break;
+
+                case led_idle_end:
+                        /* ... and on if the system is not idle */
+                        if (!(led_state & LED_STATE_CLAIMED))
+                                hw_led_state |= LED_RED;
+                        break;
+#endif
+
+                case led_red_on:
+                        if (led_state & LED_STATE_CLAIMED)
+                                hw_led_state &= ~LED_RED;
+                        break;
+
+                case led_red_off:
+                        if (led_state & LED_STATE_CLAIMED)
+                                hw_led_state |= LED_RED;
+                        break;
+
+                case led_green_on:
+                        if (led_state & LED_STATE_CLAIMED)
+                                hw_led_state &= ~LED_GREEN;
+                        break;
+
+                case led_green_off:
+                        if (led_state & LED_STATE_CLAIMED)
+                                hw_led_state |= LED_GREEN;
+                        break;
+
+                default:
+                        break;
+        }
+
+        /* Now set the GPIO state, or nothing will happen at all */
+        if (led_state & LED_STATE_ENABLED) {
+                GPSR = hw_led_state;
+                GPCR = hw_led_state ^ LED_MASK;
+        }
+
+        local_irq_restore(flags);
+}
diff --git a/arch/arm/mach-sa1100/leds-lart.c b/arch/arm/mach-sa1100/leds-lart.c
new file mode 100644
index 00000000000..0505a1fdcdb
--- /dev/null
+++ b/arch/arm/mach-sa1100/leds-lart.c
@@ -0,0 +1,101 @@
+/*
+ * linux/arch/arm/mach-sa1100/leds-lart.c
+ *
+ * (C) Erik Mouw (J.A.K.Mouw@its.tudelft.nl), April 21, 2000
+ *
+ * LART uses the LED as follows:
+ *   - GPIO23 is the LED, on if system is not idle
+ *  You can use both CONFIG_LEDS_CPU and CONFIG_LEDS_TIMER at the same
+ *  time, but in that case the timer events will still dictate the
+ *  pace of the LED.
+ */
+#include <linux/init.h>
+
+#include <mach/hardware.h>
+#include <asm/leds.h>
+#include <asm/system.h>
+
+#include "leds.h"
+
+
+#define LED_STATE_ENABLED       1
+#define LED_STATE_CLAIMED       2
+
+static unsigned int led_state;
+static unsigned int hw_led_state;
+
+#define LED_23    GPIO_GPIO23
+#define LED_MASK  (LED_23)
+
+void lart_leds_event(led_event_t evt)
+{
+        unsigned long flags;
+
+        local_irq_save(flags);
+
+        switch(evt) {
+        case led_start:
+                /* pin 23 is output pin */
+                GPDR |= LED_23;
+                hw_led_state = LED_MASK;
+                led_state = LED_STATE_ENABLED;
+                break;
+
+        case led_stop:
+                led_state &= ~LED_STATE_ENABLED;
+                break;
+
+        case led_claim:
+                led_state |= LED_STATE_CLAIMED;
+                hw_led_state = LED_MASK;
+                break;
+
+        case led_release:
+                led_state &= ~LED_STATE_CLAIMED;
+                hw_led_state = LED_MASK;
+                break;
+
+#ifdef CONFIG_LEDS_TIMER
+        case led_timer:
+                if (!(led_state & LED_STATE_CLAIMED))
+                        hw_led_state ^= LED_23;
+                break;
+#endif
+
+#ifdef CONFIG_LEDS_CPU
+        case led_idle_start:
+                /* The LART people like the LED to be off when the
+                   system is idle... */
+                if (!(led_state & LED_STATE_CLAIMED))
+                        hw_led_state &= ~LED_23;
+                break;
+
+        case led_idle_end:
+                /* ... and on if the system is not idle */
+                if (!(led_state & LED_STATE_CLAIMED))
+                        hw_led_state |= LED_23;
+                break;
+#endif
+
+        case led_red_on:
+                if (led_state & LED_STATE_CLAIMED)
+                        hw_led_state &= ~LED_23;
+                break;
+
+        case led_red_off:
+                if (led_state & LED_STATE_CLAIMED)
+                        hw_led_state |= LED_23;
+                break;
+
+        default:
+                break;
+        }
+
+        /* Now set the GPIO state, or nothing will happen at all */
+        if (led_state & LED_STATE_ENABLED) {
+                GPSR = hw_led_state;
+                GPCR = hw_led_state ^ LED_MASK;
+        }
+
+        local_irq_restore(flags);
+}
diff --git a/arch/arm/mach-sa1100/leds-simpad.c b/arch/arm/mach-sa1100/leds-simpad.c
new file mode 100644
index 00000000000..d50f4eeaa12
--- /dev/null
+++ b/arch/arm/mach-sa1100/leds-simpad.c
@@ -0,0 +1,100 @@
+/*
+ * linux/arch/arm/mach-sa1100/leds-simpad.c
+ *
+ * Author: Juergen Messerer <juergen.messerer@siemens.ch>
+ */
+#include <linux/init.h>
+
+#include <mach/hardware.h>
+#include <asm/leds.h>
+#include <asm/system.h>
+#include <mach/simpad.h>
+
+#include "leds.h"
+
+
+#define LED_STATE_ENABLED       1
+#define LED_STATE_CLAIMED       2
+
+static unsigned int led_state;
+static unsigned int hw_led_state;
+
+#define LED_GREEN       (1)
+#define LED_MASK        (1)
+
+extern void set_cs3_bit(int value);
+extern void clear_cs3_bit(int value);     
+
+void simpad_leds_event(led_event_t evt)
+{
+        switch (evt)
+        {
+        case led_start:
+                hw_led_state = LED_GREEN;
+                led_state = LED_STATE_ENABLED;
+                break;
+
+        case led_stop:
+                led_state &= ~LED_STATE_ENABLED;
+                break;
+
+        case led_claim:
+                led_state |= LED_STATE_CLAIMED;
+                hw_led_state = LED_GREEN;
+                break;
+
+        case led_release:
+                led_state &= ~LED_STATE_CLAIMED;
+                hw_led_state = LED_GREEN;
+                break;
+
+#ifdef CONFIG_LEDS_TIMER
+        case led_timer:
+                if (!(led_state & LED_STATE_CLAIMED))
+                        hw_led_state ^= LED_GREEN;
+                break;
+#endif
+
+#ifdef CONFIG_LEDS_CPU
+        case led_idle_start:
+                break;
+
+        case led_idle_end:
+                break;
+#endif
+
+        case led_halted:
+                break;
+
+        case led_green_on:
+                if (led_state & LED_STATE_CLAIMED)
+                        hw_led_state |= LED_GREEN;
+                break;
+
+        case led_green_off:
+                if (led_state & LED_STATE_CLAIMED)
+                        hw_led_state &= ~LED_GREEN;
+                break;
+
+        case led_amber_on:
+                break;
+
+        case led_amber_off:
+                break;
+
+        case led_red_on:
+                break;
+
+        case led_red_off:
+                break;
+
+        default:
+                break;
+        }
+
+        if  (led_state & LED_STATE_ENABLED)
+                set_cs3_bit(LED2_ON);
+        else 
+                clear_cs3_bit(LED2_ON);
+}
+
diff --git a/arch/arm/mach-sa1100/leds.c b/arch/arm/mach-sa1100/leds.c
new file mode 100644
index 00000000000..bbfe197fb4d
--- /dev/null
+++ b/arch/arm/mach-sa1100/leds.c
@@ -0,0 +1,52 @@
+/*
+ * linux/arch/arm/mach-sa1100/leds.c
+ *
+ * SA1100 LEDs dispatcher
+ *
+ * Copyright (C) 2001 Nicolas Pitre
+ */
+#include <linux/compiler.h>
+#include <linux/init.h>
+
+#include <asm/leds.h>
+#include <asm/mach-types.h>
+
+#include "leds.h"
+
+static int __init
+sa1100_leds_init(void)
+{
+        if (machine_is_assabet())
+                leds_event = assabet_leds_event;
+        if (machine_is_consus())
+                leds_event = consus_leds_event;
+        if (machine_is_badge4())
+                leds_event = badge4_leds_event;
+        if (machine_is_brutus())
+                leds_event = brutus_leds_event;
+        if (machine_is_cerf())
+                leds_event = cerf_leds_event;
+        if (machine_is_flexanet())
+                leds_event = flexanet_leds_event;
+        if (machine_is_graphicsclient())
+                leds_event = graphicsclient_leds_event;
+        if (machine_is_hackkit())
+                leds_event = hackkit_leds_event;
+        if (machine_is_lart())
+                leds_event = lart_leds_event;
+        if (machine_is_pfs168())
+                leds_event = pfs168_leds_event;
+        if (machine_is_graphicsmaster())
+                leds_event = graphicsmaster_leds_event;
+        if (machine_is_adsbitsy())
+                leds_event = adsbitsy_leds_event;
+        if (machine_is_pt_system3())
+                leds_event = system3_leds_event;
+        if (machine_is_simpad())
+                leds_event = simpad_leds_event; /* what about machine registry? including led, apm... -zecke */
+
+        leds_event(led_start);
+        return 0;
+}
+
+core_initcall(sa1100_leds_init);
diff --git a/arch/arm/mach-sa1100/leds.h b/arch/arm/mach-sa1100/leds.h
new file mode 100644
index 00000000000..68cc9f773d6
--- /dev/null
+++ b/arch/arm/mach-sa1100/leds.h
@@ -0,0 +1,14 @@
+extern void assabet_leds_event(led_event_t evt);
+extern void badge4_leds_event(led_event_t evt);
+extern void consus_leds_event(led_event_t evt);
+extern void brutus_leds_event(led_event_t evt);
+extern void cerf_leds_event(led_event_t evt);
+extern void flexanet_leds_event(led_event_t evt);
+extern void graphicsclient_leds_event(led_event_t evt);
+extern void hackkit_leds_event(led_event_t evt);
+extern void lart_leds_event(led_event_t evt);
+extern void pfs168_leds_event(led_event_t evt);
+extern void graphicsmaster_leds_event(led_event_t evt);
+extern void adsbitsy_leds_event(led_event_t evt);
+extern void system3_leds_event(led_event_t evt);
+extern void simpad_leds_event(led_event_t evt);