danube to ifxmips transition
[openwrt/svn-archive/archive.git] / target / linux / ifxmips / files / drivers / char / danube_gpio.c
index dbdb71e..6ac9ec6 100644 (file)
 #include <linux/ioctl.h>
 #include <asm/semaphore.h>
 #include <asm/uaccess.h>
-#include <asm/danube/danube.h>
-#include <asm/danube/danube_ioctl.h>
+#include <asm/ifxmips/ifxmips.h>
+#include <asm/ifxmips/ifxmips_ioctl.h>
 
 #define MAX_PORTS                      2
 #define PINS_PER_PORT          16
 
-static unsigned int danube_gpio_major = 0;
+static unsigned int ifxmips_gpio_major = 0;
 
 /* TODO do we need this ? */
 static struct semaphore port_sem;
 
 /* TODO do we really need this ? return in a define is forbidden by coding style */
-#define DANUBE_GPIO_SANITY             {if (port > MAX_PORTS || pin > PINS_PER_PORT) return -EINVAL; }
+#define IFXMIPS_GPIO_SANITY            {if (port > MAX_PORTS || pin > PINS_PER_PORT) return -EINVAL; }
 
 int
-danube_port_reserve_pin (unsigned int port, unsigned int pin)
+ifxmips_port_reserve_pin (unsigned int port, unsigned int pin)
 {
-       DANUBE_GPIO_SANITY;
+       IFXMIPS_GPIO_SANITY;
        printk("%s : call to obseleted function\n", __func__);
 
        return 0;
 }
-EXPORT_SYMBOL(danube_port_reserve_pin);
+EXPORT_SYMBOL(ifxmips_port_reserve_pin);
 
 int
-danube_port_free_pin (unsigned int port, unsigned int pin)
+ifxmips_port_free_pin (unsigned int port, unsigned int pin)
 {
-       DANUBE_GPIO_SANITY;
+       IFXMIPS_GPIO_SANITY;
        printk("%s : call to obseleted function\n", __func__);
 
        return 0;
 }
-EXPORT_SYMBOL(danube_port_free_pin);
+EXPORT_SYMBOL(ifxmips_port_free_pin);
 
 int
-danube_port_set_open_drain (unsigned int port, unsigned int pin)
+ifxmips_port_set_open_drain (unsigned int port, unsigned int pin)
 {
-       DANUBE_GPIO_SANITY;
-       writel(readl(DANUBE_GPIO_P0_OD + (port * 0x30)) | (1 << pin), DANUBE_GPIO_P0_OD);
+       IFXMIPS_GPIO_SANITY;
+       writel(readl(IFXMIPS_GPIO_P0_OD + (port * 0x30)) | (1 << pin), IFXMIPS_GPIO_P0_OD);
 
        return 0;
 }
-EXPORT_SYMBOL(danube_port_set_open_drain);
+EXPORT_SYMBOL(ifxmips_port_set_open_drain);
 
 int
-danube_port_clear_open_drain (unsigned int port, unsigned int pin)
+ifxmips_port_clear_open_drain (unsigned int port, unsigned int pin)
 {
-       DANUBE_GPIO_SANITY;
-       writel(readl(DANUBE_GPIO_P0_OD + (port * 0x30)) & ~(1 << pin), DANUBE_GPIO_P0_OD);
+       IFXMIPS_GPIO_SANITY;
+       writel(readl(IFXMIPS_GPIO_P0_OD + (port * 0x30)) & ~(1 << pin), IFXMIPS_GPIO_P0_OD);
 
        return 0;
 }
-EXPORT_SYMBOL(danube_port_clear_open_drain);
+EXPORT_SYMBOL(ifxmips_port_clear_open_drain);
 
 int
-danube_port_set_pudsel (unsigned int port, unsigned int pin)
+ifxmips_port_set_pudsel (unsigned int port, unsigned int pin)
 {
-    DANUBE_GPIO_SANITY;
-       writel(readl(DANUBE_GPIO_P0_PUDSEL + (port * 0x30)) | (1 << pin), DANUBE_GPIO_P0_PUDSEL);
+    IFXMIPS_GPIO_SANITY;
+       writel(readl(IFXMIPS_GPIO_P0_PUDSEL + (port * 0x30)) | (1 << pin), IFXMIPS_GPIO_P0_PUDSEL);
 
        return 0;
 }
-EXPORT_SYMBOL(danube_port_set_pudsel);
+EXPORT_SYMBOL(ifxmips_port_set_pudsel);
 
 int
-danube_port_clear_pudsel (unsigned int port, unsigned int pin)
+ifxmips_port_clear_pudsel (unsigned int port, unsigned int pin)
 {
-    DANUBE_GPIO_SANITY;
-       writel(readl(DANUBE_GPIO_P0_PUDSEL + (port * 0x30)) & ~(1 << pin), DANUBE_GPIO_P0_PUDSEL);
+    IFXMIPS_GPIO_SANITY;
+       writel(readl(IFXMIPS_GPIO_P0_PUDSEL + (port * 0x30)) & ~(1 << pin), IFXMIPS_GPIO_P0_PUDSEL);
 
        return 0;
 }
-EXPORT_SYMBOL(danube_port_clear_pudsel);
+EXPORT_SYMBOL(ifxmips_port_clear_pudsel);
 
 int
-danube_port_set_puden (unsigned int port, unsigned int pin)
+ifxmips_port_set_puden (unsigned int port, unsigned int pin)
 {
-    DANUBE_GPIO_SANITY;
-       writel(readl(DANUBE_GPIO_P0_PUDEN + (port * 0x30)) | (1 << pin), DANUBE_GPIO_P0_PUDEN);
+    IFXMIPS_GPIO_SANITY;
+       writel(readl(IFXMIPS_GPIO_P0_PUDEN + (port * 0x30)) | (1 << pin), IFXMIPS_GPIO_P0_PUDEN);
 
        return 0;
 }
-EXPORT_SYMBOL(danube_port_set_puden);
+EXPORT_SYMBOL(ifxmips_port_set_puden);
 
 int
-danube_port_clear_puden (unsigned int port, unsigned int pin)
+ifxmips_port_clear_puden (unsigned int port, unsigned int pin)
 {
-    DANUBE_GPIO_SANITY;
-       writel(readl(DANUBE_GPIO_P0_PUDEN + (port * 0x30)) & ~(1 << pin), DANUBE_GPIO_P0_PUDEN);
+    IFXMIPS_GPIO_SANITY;
+       writel(readl(IFXMIPS_GPIO_P0_PUDEN + (port * 0x30)) & ~(1 << pin), IFXMIPS_GPIO_P0_PUDEN);
 
        return 0;
 }
-EXPORT_SYMBOL(danube_port_clear_puden);
+EXPORT_SYMBOL(ifxmips_port_clear_puden);
 
 int
-danube_port_set_stoff (unsigned int port, unsigned int pin)
+ifxmips_port_set_stoff (unsigned int port, unsigned int pin)
 {
-    DANUBE_GPIO_SANITY;
-       writel(readl(DANUBE_GPIO_P0_STOFF + (port * 0x30)) | (1 << pin), DANUBE_GPIO_P0_STOFF);
+    IFXMIPS_GPIO_SANITY;
+       writel(readl(IFXMIPS_GPIO_P0_STOFF + (port * 0x30)) | (1 << pin), IFXMIPS_GPIO_P0_STOFF);
 
        return 0;
 }
-EXPORT_SYMBOL(danube_port_set_stoff);
+EXPORT_SYMBOL(ifxmips_port_set_stoff);
 
 int
-danube_port_clear_stoff (unsigned int port, unsigned int pin)
+ifxmips_port_clear_stoff (unsigned int port, unsigned int pin)
 {
-    DANUBE_GPIO_SANITY;
-       writel(readl(DANUBE_GPIO_P0_STOFF + (port * 0x30)) & ~(1 << pin), DANUBE_GPIO_P0_STOFF);
+    IFXMIPS_GPIO_SANITY;
+       writel(readl(IFXMIPS_GPIO_P0_STOFF + (port * 0x30)) & ~(1 << pin), IFXMIPS_GPIO_P0_STOFF);
 
        return 0;
 }
-EXPORT_SYMBOL(danube_port_clear_stoff);
+EXPORT_SYMBOL(ifxmips_port_clear_stoff);
 
 int
-danube_port_set_dir_out (unsigned int port, unsigned int pin)
+ifxmips_port_set_dir_out (unsigned int port, unsigned int pin)
 {
-    DANUBE_GPIO_SANITY;
-       writel(readl(DANUBE_GPIO_P0_DIR + (port * 0x30)) | (1 << pin), DANUBE_GPIO_P0_DIR);
+    IFXMIPS_GPIO_SANITY;
+       writel(readl(IFXMIPS_GPIO_P0_DIR + (port * 0x30)) | (1 << pin), IFXMIPS_GPIO_P0_DIR);
 
        return 0;
 }
-EXPORT_SYMBOL(danube_port_set_dir_out);
+EXPORT_SYMBOL(ifxmips_port_set_dir_out);
 
 int
-danube_port_set_dir_in (unsigned int port, unsigned int pin)
+ifxmips_port_set_dir_in (unsigned int port, unsigned int pin)
 {
-    DANUBE_GPIO_SANITY;
-       writel(readl(DANUBE_GPIO_P0_DIR + (port * 0x30)) & ~(1 << pin), DANUBE_GPIO_P0_DIR);
+    IFXMIPS_GPIO_SANITY;
+       writel(readl(IFXMIPS_GPIO_P0_DIR + (port * 0x30)) & ~(1 << pin), IFXMIPS_GPIO_P0_DIR);
 
        return 0;
 }
-EXPORT_SYMBOL(danube_port_set_dir_in);
+EXPORT_SYMBOL(ifxmips_port_set_dir_in);
 
 int
-danube_port_set_output (unsigned int port, unsigned int pin)
+ifxmips_port_set_output (unsigned int port, unsigned int pin)
 {
-    DANUBE_GPIO_SANITY;
-       writel(readl(DANUBE_GPIO_P0_OUT + (port * 0x30)) | (1 << pin), DANUBE_GPIO_P0_OUT);
+    IFXMIPS_GPIO_SANITY;
+       writel(readl(IFXMIPS_GPIO_P0_OUT + (port * 0x30)) | (1 << pin), IFXMIPS_GPIO_P0_OUT);
 
        return 0;
 }
-EXPORT_SYMBOL(danube_port_set_output);
+EXPORT_SYMBOL(ifxmips_port_set_output);
 
 int
-danube_port_clear_output (unsigned int port, unsigned int pin)
+ifxmips_port_clear_output (unsigned int port, unsigned int pin)
 {
-    DANUBE_GPIO_SANITY;
-       writel(readl(DANUBE_GPIO_P0_OUT + (port * 0x30)) & ~(1 << pin), DANUBE_GPIO_P0_OUT);
+    IFXMIPS_GPIO_SANITY;
+       writel(readl(IFXMIPS_GPIO_P0_OUT + (port * 0x30)) & ~(1 << pin), IFXMIPS_GPIO_P0_OUT);
 
        return 0;
 }
-EXPORT_SYMBOL(danube_port_clear_output);
+EXPORT_SYMBOL(ifxmips_port_clear_output);
 
 int
-danube_port_get_input (unsigned int port, unsigned int pin)
+ifxmips_port_get_input (unsigned int port, unsigned int pin)
 {
-    DANUBE_GPIO_SANITY;
+    IFXMIPS_GPIO_SANITY;
 
-       if (readl(DANUBE_GPIO_P0_IN + (port * 0x30)) & (1 << pin))
+       if (readl(IFXMIPS_GPIO_P0_IN + (port * 0x30)) & (1 << pin))
                return 0;
        else
                return 1;
 }
-EXPORT_SYMBOL(danube_port_get_input);
+EXPORT_SYMBOL(ifxmips_port_get_input);
 
 int
-danube_port_set_altsel0 (unsigned int port, unsigned int pin)
+ifxmips_port_set_altsel0 (unsigned int port, unsigned int pin)
 {
-    DANUBE_GPIO_SANITY;
-       writel(readl(DANUBE_GPIO_P0_ALTSEL0 + (port * 0x30)) | (1 << pin), DANUBE_GPIO_P0_ALTSEL0);
+    IFXMIPS_GPIO_SANITY;
+       writel(readl(IFXMIPS_GPIO_P0_ALTSEL0 + (port * 0x30)) | (1 << pin), IFXMIPS_GPIO_P0_ALTSEL0);
 
        return 0;
 }
-EXPORT_SYMBOL(danube_port_set_altsel0);
+EXPORT_SYMBOL(ifxmips_port_set_altsel0);
 
 int
-danube_port_clear_altsel0 (unsigned int port, unsigned int pin)
+ifxmips_port_clear_altsel0 (unsigned int port, unsigned int pin)
 {
-    DANUBE_GPIO_SANITY;
-       writel(readl(DANUBE_GPIO_P0_ALTSEL0 + (port * 0x30)) & ~(1 << pin), DANUBE_GPIO_P0_ALTSEL0);
+    IFXMIPS_GPIO_SANITY;
+       writel(readl(IFXMIPS_GPIO_P0_ALTSEL0 + (port * 0x30)) & ~(1 << pin), IFXMIPS_GPIO_P0_ALTSEL0);
 
        return 0;
 }
-EXPORT_SYMBOL(danube_port_clear_altsel0);
+EXPORT_SYMBOL(ifxmips_port_clear_altsel0);
 
 int
-danube_port_set_altsel1 (unsigned int port, unsigned int pin)
+ifxmips_port_set_altsel1 (unsigned int port, unsigned int pin)
 {
-    DANUBE_GPIO_SANITY;
-       writel(readl(DANUBE_GPIO_P0_ALTSEL1 + (port * 0x30)) | (1 << pin), DANUBE_GPIO_P0_ALTSEL1);
+    IFXMIPS_GPIO_SANITY;
+       writel(readl(IFXMIPS_GPIO_P0_ALTSEL1 + (port * 0x30)) | (1 << pin), IFXMIPS_GPIO_P0_ALTSEL1);
 
        return 0;
 }
-EXPORT_SYMBOL(danube_port_set_altsel1);
+EXPORT_SYMBOL(ifxmips_port_set_altsel1);
 
 int
-danube_port_clear_altsel1 (unsigned int port, unsigned int pin)
+ifxmips_port_clear_altsel1 (unsigned int port, unsigned int pin)
 {
-    DANUBE_GPIO_SANITY;
-       writel(readl(DANUBE_GPIO_P0_ALTSEL1 + (port * 0x30)) & ~(1 << pin), DANUBE_GPIO_P0_ALTSEL1);
+    IFXMIPS_GPIO_SANITY;
+       writel(readl(IFXMIPS_GPIO_P0_ALTSEL1 + (port * 0x30)) & ~(1 << pin), IFXMIPS_GPIO_P0_ALTSEL1);
 
        return 0;
 }
-EXPORT_SYMBOL(danube_port_clear_altsel1);
+EXPORT_SYMBOL(ifxmips_port_clear_altsel1);
 
-long danube_port_read_procmem_helper(char* tag, u32* in_reg, char *buf)
+long ifxmips_port_read_procmem_helper(char* tag, u32* in_reg, char *buf)
 {
        u32 reg, bit = 0;
        unsigned int len, t;
@@ -252,10 +252,10 @@ long danube_port_read_procmem_helper(char* tag, u32* in_reg, char *buf)
 }
 
 int
-danube_port_read_procmem (char *buf, char **start, off_t offset, int count,
+ifxmips_port_read_procmem (char *buf, char **start, off_t offset, int count,
                          int *eof, void *data)
 {
-       long len = sprintf (buf, "\nDanube Port Settings\n");
+       long len = sprintf (buf, "\nIFXMips Port Settings\n");
 
        len += sprintf (buf + len,
                        "         3         2         1         0\n");
@@ -264,24 +264,24 @@ danube_port_read_procmem (char *buf, char **start, off_t offset, int count,
        len += sprintf (buf + len,
                        "----------------------------------------\n");
 
-       len += danube_port_read_procmem_helper("P0-OUT", DANUBE_GPIO_P0_OUT, &buf[len]);
-       len += danube_port_read_procmem_helper("P1-OUT", DANUBE_GPIO_P1_OUT, &buf[len]);
-       len += danube_port_read_procmem_helper("P0-IN ", DANUBE_GPIO_P0_IN, &buf[len]);
-       len += danube_port_read_procmem_helper("P1-IN ", DANUBE_GPIO_P1_IN, &buf[len]);
-       len += danube_port_read_procmem_helper("P0-DIR", DANUBE_GPIO_P0_DIR, &buf[len]);
-       len += danube_port_read_procmem_helper("P1-DIR", DANUBE_GPIO_P1_DIR, &buf[len]);
-       len += danube_port_read_procmem_helper("P0-STO ", DANUBE_GPIO_P0_STOFF, &buf[len]);
-       len += danube_port_read_procmem_helper("P1-STO ", DANUBE_GPIO_P1_STOFF, &buf[len]);
-       len += danube_port_read_procmem_helper("P0-PUDE", DANUBE_GPIO_P0_PUDEN, &buf[len]);
-       len += danube_port_read_procmem_helper("P1-PUDE", DANUBE_GPIO_P1_PUDEN, &buf[len]);
-       len += danube_port_read_procmem_helper("P0-OD  ", DANUBE_GPIO_P0_OD, &buf[len]);
-       len += danube_port_read_procmem_helper("P1-OD  ", DANUBE_GPIO_P1_OD, &buf[len]);
-       len += danube_port_read_procmem_helper("P0-PUDS", DANUBE_GPIO_P0_PUDSEL, &buf[len]);
-       len += danube_port_read_procmem_helper("P1-PUDS", DANUBE_GPIO_P1_PUDSEL, &buf[len]);
-       len += danube_port_read_procmem_helper("P0-ALT0", DANUBE_GPIO_P0_ALTSEL0, &buf[len]);
-       len += danube_port_read_procmem_helper("P1-ALT0", DANUBE_GPIO_P1_ALTSEL0, &buf[len]);
-       len += danube_port_read_procmem_helper("P0-ALT1", DANUBE_GPIO_P0_ALTSEL1, &buf[len]);
-       len += danube_port_read_procmem_helper("P1-ALT1", DANUBE_GPIO_P1_ALTSEL1, &buf[len]);
+       len += ifxmips_port_read_procmem_helper("P0-OUT", IFXMIPS_GPIO_P0_OUT, &buf[len]);
+       len += ifxmips_port_read_procmem_helper("P1-OUT", IFXMIPS_GPIO_P1_OUT, &buf[len]);
+       len += ifxmips_port_read_procmem_helper("P0-IN ", IFXMIPS_GPIO_P0_IN, &buf[len]);
+       len += ifxmips_port_read_procmem_helper("P1-IN ", IFXMIPS_GPIO_P1_IN, &buf[len]);
+       len += ifxmips_port_read_procmem_helper("P0-DIR", IFXMIPS_GPIO_P0_DIR, &buf[len]);
+       len += ifxmips_port_read_procmem_helper("P1-DIR", IFXMIPS_GPIO_P1_DIR, &buf[len]);
+       len += ifxmips_port_read_procmem_helper("P0-STO ", IFXMIPS_GPIO_P0_STOFF, &buf[len]);
+       len += ifxmips_port_read_procmem_helper("P1-STO ", IFXMIPS_GPIO_P1_STOFF, &buf[len]);
+       len += ifxmips_port_read_procmem_helper("P0-PUDE", IFXMIPS_GPIO_P0_PUDEN, &buf[len]);
+       len += ifxmips_port_read_procmem_helper("P1-PUDE", IFXMIPS_GPIO_P1_PUDEN, &buf[len]);
+       len += ifxmips_port_read_procmem_helper("P0-OD  ", IFXMIPS_GPIO_P0_OD, &buf[len]);
+       len += ifxmips_port_read_procmem_helper("P1-OD  ", IFXMIPS_GPIO_P1_OD, &buf[len]);
+       len += ifxmips_port_read_procmem_helper("P0-PUDS", IFXMIPS_GPIO_P0_PUDSEL, &buf[len]);
+       len += ifxmips_port_read_procmem_helper("P1-PUDS", IFXMIPS_GPIO_P1_PUDSEL, &buf[len]);
+       len += ifxmips_port_read_procmem_helper("P0-ALT0", IFXMIPS_GPIO_P0_ALTSEL0, &buf[len]);
+       len += ifxmips_port_read_procmem_helper("P1-ALT0", IFXMIPS_GPIO_P1_ALTSEL0, &buf[len]);
+       len += ifxmips_port_read_procmem_helper("P0-ALT1", IFXMIPS_GPIO_P0_ALTSEL1, &buf[len]);
+       len += ifxmips_port_read_procmem_helper("P1-ALT1", IFXMIPS_GPIO_P1_ALTSEL1, &buf[len]);
        len = len + sprintf (buf + len, "\n\n");
 
        *eof = 1;
@@ -290,39 +290,39 @@ danube_port_read_procmem (char *buf, char **start, off_t offset, int count,
 }
 
 static int
-danube_port_open (struct inode *inode, struct file *filep)
+ifxmips_port_open (struct inode *inode, struct file *filep)
 {
        return 0;
 }
 
 static int
-danube_port_release (struct inode *inode, struct file *filelp)
+ifxmips_port_release (struct inode *inode, struct file *filelp)
 {
        return 0;
 }
 
 static int
-danube_port_ioctl (struct inode *inode, struct file *filp,
+ifxmips_port_ioctl (struct inode *inode, struct file *filp,
                        unsigned int cmd, unsigned long arg)
 {
        int ret = 0;
-       volatile struct danube_port_ioctl_parm parm;
+       volatile struct ifxmips_port_ioctl_parm parm;
 
-       if (_IOC_TYPE (cmd) != DANUBE_PORT_IOC_MAGIC)
+       if (_IOC_TYPE (cmd) != IFXMIPS_PORT_IOC_MAGIC)
                return -EINVAL;
 
        if (_IOC_DIR (cmd) & _IOC_WRITE) {
                if (!access_ok
                    (VERIFY_READ, arg,
-                    sizeof (struct danube_port_ioctl_parm)))
+                    sizeof (struct ifxmips_port_ioctl_parm)))
                        return -EFAULT;
                ret = copy_from_user ((void *) &parm, (void *) arg,
-                                     sizeof (struct danube_port_ioctl_parm));
+                                     sizeof (struct ifxmips_port_ioctl_parm));
        }
        if (_IOC_DIR (cmd) & _IOC_READ) {
                if (!access_ok
                    (VERIFY_WRITE, arg,
-                    sizeof (struct danube_port_ioctl_parm)))
+                    sizeof (struct ifxmips_port_ioctl_parm)))
                        return -EFAULT;
        }
 
@@ -330,66 +330,66 @@ danube_port_ioctl (struct inode *inode, struct file *filp,
                return -EBUSY;
 
        switch (cmd) {
-       case DANUBE_PORT_IOCOD:
+       case IFXMIPS_PORT_IOCOD:
                if (parm.value == 0x00)
-                       danube_port_clear_open_drain(parm.port, parm.pin);
+                       ifxmips_port_clear_open_drain(parm.port, parm.pin);
                else
-                       danube_port_set_open_drain(parm.port, parm.pin);
+                       ifxmips_port_set_open_drain(parm.port, parm.pin);
                break;
 
-       case DANUBE_PORT_IOCPUDSEL:
+       case IFXMIPS_PORT_IOCPUDSEL:
                if (parm.value == 0x00)
-                       danube_port_clear_pudsel(parm.port, parm.pin);
+                       ifxmips_port_clear_pudsel(parm.port, parm.pin);
                else
-                       danube_port_set_pudsel(parm.port, parm.pin);
+                       ifxmips_port_set_pudsel(parm.port, parm.pin);
                break;
 
-       case DANUBE_PORT_IOCPUDEN:
+       case IFXMIPS_PORT_IOCPUDEN:
                if (parm.value == 0x00)
-                       danube_port_clear_puden(parm.port, parm.pin);
+                       ifxmips_port_clear_puden(parm.port, parm.pin);
                else
-                       danube_port_set_puden(parm.port, parm.pin);
+                       ifxmips_port_set_puden(parm.port, parm.pin);
                break;
 
-       case DANUBE_PORT_IOCSTOFF:
+       case IFXMIPS_PORT_IOCSTOFF:
                if (parm.value == 0x00)
-                       danube_port_clear_stoff(parm.port, parm.pin);
+                       ifxmips_port_clear_stoff(parm.port, parm.pin);
                else
-                       danube_port_set_stoff(parm.port, parm.pin);
+                       ifxmips_port_set_stoff(parm.port, parm.pin);
                break;
 
-       case DANUBE_PORT_IOCDIR:
+       case IFXMIPS_PORT_IOCDIR:
                if (parm.value == 0x00)
-                       danube_port_set_dir_in(parm.port, parm.pin);
+                       ifxmips_port_set_dir_in(parm.port, parm.pin);
                else
-                       danube_port_set_dir_out(parm.port, parm.pin);
+                       ifxmips_port_set_dir_out(parm.port, parm.pin);
                break;
 
-       case DANUBE_PORT_IOCOUTPUT:
+       case IFXMIPS_PORT_IOCOUTPUT:
                if (parm.value == 0x00)
-                       danube_port_clear_output(parm.port, parm.pin);
+                       ifxmips_port_clear_output(parm.port, parm.pin);
                else
-                       danube_port_set_output(parm.port, parm.pin);
+                       ifxmips_port_set_output(parm.port, parm.pin);
                break;
 
-       case DANUBE_PORT_IOCALTSEL0:
+       case IFXMIPS_PORT_IOCALTSEL0:
                if (parm.value == 0x00)
-                       danube_port_clear_altsel0(parm.port, parm.pin);
+                       ifxmips_port_clear_altsel0(parm.port, parm.pin);
                else
-                       danube_port_set_altsel0(parm.port, parm.pin);
+                       ifxmips_port_set_altsel0(parm.port, parm.pin);
                break;
 
-       case DANUBE_PORT_IOCALTSEL1:
+       case IFXMIPS_PORT_IOCALTSEL1:
                if (parm.value == 0x00)
-                       danube_port_clear_altsel1(parm.port, parm.pin);
+                       ifxmips_port_clear_altsel1(parm.port, parm.pin);
                else
-                       danube_port_set_altsel1(parm.port, parm.pin);
+                       ifxmips_port_set_altsel1(parm.port, parm.pin);
                break;
 
-       case DANUBE_PORT_IOCINPUT:
-               parm.value = danube_port_get_input(parm.port, parm.pin);
+       case IFXMIPS_PORT_IOCINPUT:
+               parm.value = ifxmips_port_get_input(parm.port, parm.pin);
                copy_to_user((void*)arg, (void*)&parm,
-                       sizeof(struct danube_port_ioctl_parm));
+                       sizeof(struct ifxmips_port_ioctl_parm));
                break;
 
        default:
@@ -402,41 +402,41 @@ danube_port_ioctl (struct inode *inode, struct file *filp,
 }
 
 static struct file_operations port_fops = {
-      .open = danube_port_open,
-      .release = danube_port_release,
-      .ioctl = danube_port_ioctl
+      .open = ifxmips_port_open,
+      .release = ifxmips_port_release,
+      .ioctl = ifxmips_port_ioctl
 };
 
 int __init
-danube_gpio_init (void)
+ifxmips_gpio_init (void)
 {
        int retval = 0;
 
        sema_init (&port_sem, 1);
 
-       danube_gpio_major = register_chrdev(0, "danube_gpio", &port_fops);
-       if (!danube_gpio_major)
+       ifxmips_gpio_major = register_chrdev(0, "ifxmips_gpio", &port_fops);
+       if (!ifxmips_gpio_major)
        {
-               printk("danube-port: Error! Could not register port device. #%d\n", danube_gpio_major);
+               printk("ifxmips-port: Error! Could not register port device. #%d\n", ifxmips_gpio_major);
                retval = -EINVAL;
                goto out;
        }
 
-       create_proc_read_entry("danube_gpio", 0, NULL,
-                               danube_port_read_procmem, NULL);
+       create_proc_read_entry("ifxmips_gpio", 0, NULL,
+                               ifxmips_port_read_procmem, NULL);
 
-       printk("registered danube gpio driver\n");
+       printk("registered ifxmips gpio driver\n");
 
 out:
        return retval;
 }
 
 void __exit
-danube_gpio_exit (void)
+ifxmips_gpio_exit (void)
 {
-       unregister_chrdev(danube_gpio_major, "danube_gpio");
-       remove_proc_entry("danube_gpio", NULL);
+       unregister_chrdev(ifxmips_gpio_major, "ifxmips_gpio");
+       remove_proc_entry("ifxmips_gpio", NULL);
 }
 
-module_init(danube_gpio_init);
-module_exit(danube_gpio_exit);
+module_init(ifxmips_gpio_init);
+module_exit(ifxmips_gpio_exit);