lkml.org 
[lkml]   [2005]   [Apr]   [4]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    SubjectRe: iomapping a big endian area
    From
    Date
    On Mon, 2005-04-04 at 16:41 +0100, David Vrabel wrote:
    > The Network Processing Engines in the Intel IXP425 are big-endian and
    > its XScale core may be run in little-endian mode. There's a bunch of
    > gotchas related to running in little-endian mode so you typically run
    > the IXP425 in big-endian mode, though.

    Yes, based on feedback from Mips people and others pointing out the
    existence of the motorola rapidio bus, which is BE, I give in and agree
    that the io{read,write}{16,32}be are the way to go.

    How does the attached look?

    James

    ===== arch/parisc/lib/iomap.c 1.1 vs edited =====
    --- 1.1/arch/parisc/lib/iomap.c 2005-01-10 08:00:46 -06:00
    +++ edited/arch/parisc/lib/iomap.c 2005-04-04 13:53:49 -05:00
    @@ -43,10 +43,14 @@
    struct iomap_ops {
    unsigned int (*read8)(void __iomem *);
    unsigned int (*read16)(void __iomem *);
    + unsigned int (*read16be)(void __iomem *);
    unsigned int (*read32)(void __iomem *);
    + unsigned int (*read32be)(void __iomem *);
    void (*write8)(u8, void __iomem *);
    void (*write16)(u16, void __iomem *);
    + void (*write16be)(u16, void __iomem *);
    void (*write32)(u32, void __iomem *);
    + void (*write32be)(u32, void __iomem *);
    void (*read8r)(void __iomem *, void *, unsigned long);
    void (*read16r)(void __iomem *, void *, unsigned long);
    void (*read32r)(void __iomem *, void *, unsigned long);
    @@ -122,9 +126,13 @@
    static const struct iomap_ops ioport_ops = {
    ioport_read8,
    ioport_read16,
    + ioport_read16,
    + ioport_read32,
    ioport_read32,
    ioport_write8,
    ioport_write16,
    + ioport_write16,
    + ioport_write32,
    ioport_write32,
    ioport_read8r,
    ioport_read16r,
    @@ -146,11 +154,21 @@
    return readw(addr);
    }

    +static unsigned int iomem_read16be(void __iomem *addr)
    +{
    + return __raw_readw(addr);
    +}
    +
    static unsigned int iomem_read32(void __iomem *addr)
    {
    return readl(addr);
    }

    +static unsigned int iomem_read32be(void __iomem *addr)
    +{
    + return __raw_readl(addr);
    +}
    +
    static void iomem_write8(u8 datum, void __iomem *addr)
    {
    writeb(datum, addr);
    @@ -161,11 +179,21 @@
    writew(datum, addr);
    }

    +static void iomem_write16be(u16 datum, void __iomem *addr)
    +{
    + __raw_writew(datum, addr);
    +}
    +
    static void iomem_write32(u32 datum, void __iomem *addr)
    {
    writel(datum, addr);
    }

    +static void iomem_write32be(u32 datum, void __iomem *addr)
    +{
    + __raw_writel(datum, addr);
    +}
    +
    static void iomem_read8r(void __iomem *addr, void *dst, unsigned long count)
    {
    while (count--) {
    @@ -217,10 +245,14 @@
    static const struct iomap_ops iomem_ops = {
    iomem_read8,
    iomem_read16,
    + iomem_read16be,
    iomem_read32,
    + iomem_read32be,
    iomem_write8,
    iomem_write16,
    + iomem_write16be,
    iomem_write32,
    + iomem_write32be,
    iomem_read8r,
    iomem_read16r,
    iomem_read32r,
    @@ -253,6 +285,13 @@
    return le16_to_cpup((u16 *)addr);
    }

    +unsigned int ioread16be(void __iomem *addr)
    +{
    + if (unlikely(INDIRECT_ADDR(addr)))
    + return iomap_ops[ADDR_TO_REGION(addr)]->read16be(addr);
    + return *((u16 *)addr);
    +}
    +
    unsigned int ioread32(void __iomem *addr)
    {
    if (unlikely(INDIRECT_ADDR(addr)))
    @@ -260,6 +299,13 @@
    return le32_to_cpup((u32 *)addr);
    }

    +unsigned int ioread32be(void __iomem *addr)
    +{
    + if (unlikely(INDIRECT_ADDR(addr)))
    + return iomap_ops[ADDR_TO_REGION(addr)]->read32be(addr);
    + return *((u32 *)addr);
    +}
    +
    void iowrite8(u8 datum, void __iomem *addr)
    {
    if (unlikely(INDIRECT_ADDR(addr))) {
    @@ -278,12 +324,30 @@
    }
    }

    +void iowrite16be(u16 datum, void __iomem *addr)
    +{
    + if (unlikely(INDIRECT_ADDR(addr))) {
    + iomap_ops[ADDR_TO_REGION(addr)]->write16be(datum, addr);
    + } else {
    + *((u16 *)addr) = datum;
    + }
    +}
    +
    void iowrite32(u32 datum, void __iomem *addr)
    {
    if (unlikely(INDIRECT_ADDR(addr))) {
    iomap_ops[ADDR_TO_REGION(addr)]->write32(datum, addr);
    } else {
    *((u32 *)addr) = cpu_to_le32(datum);
    + }
    +}
    +
    +void iowrite32be(u32 datum, void __iomem *addr)
    +{
    + if (unlikely(INDIRECT_ADDR(addr))) {
    + iomap_ops[ADDR_TO_REGION(addr)]->write32be(datum, addr);
    + } else {
    + *((u32 *)addr) = datum;
    }
    }

    ===== include/asm-generic/iomap.h 1.3 vs edited =====
    --- 1.3/include/asm-generic/iomap.h 2004-09-14 18:28:47 -05:00
    +++ edited/include/asm-generic/iomap.h 2005-04-04 12:06:14 -05:00
    @@ -2,6 +2,7 @@
    #define __GENERIC_IO_H

    #include <linux/linkage.h>
    +#include <asm/byteorder.h>

    /*
    * These are the "generic" interfaces for doing new-style
    @@ -26,11 +27,15 @@
    */
    extern unsigned int fastcall ioread8(void __iomem *);
    extern unsigned int fastcall ioread16(void __iomem *);
    +extern unsigned int fastcall ioread16be(void __iomem *);
    extern unsigned int fastcall ioread32(void __iomem *);
    +extern unsigned int fastcall ioread32be(void __iomem *);

    extern void fastcall iowrite8(u8, void __iomem *);
    extern void fastcall iowrite16(u16, void __iomem *);
    +extern void fastcall iowrite16be(u16, void __iomem *);
    extern void fastcall iowrite32(u32, void __iomem *);
    +extern void fastcall iowrite32be(u32, void __iomem *);

    /*
    * "string" versions of the above. Note that they
    ===== lib/iomap.c 1.6 vs edited =====
    --- 1.6/lib/iomap.c 2004-10-28 02:39:50 -05:00
    +++ edited/lib/iomap.c 2005-04-04 13:52:51 -05:00
    @@ -58,13 +58,23 @@
    {
    IO_COND(addr, return inw(port), return readw(addr));
    }
    +unsigned int fastcall ioread16be(void __iomem *addr)
    +{
    + IO_COND(addr, return inw(port), return cpu_to_be16(__raw_readw(addr)));
    +}
    unsigned int fastcall ioread32(void __iomem *addr)
    {
    IO_COND(addr, return inl(port), return readl(addr));
    }
    +unsigned int fastcall ioread32be(void __iomem *addr)
    +{
    + IO_COND(addr, return inl(port), return cpu_to_be32(__raw_readl(addr)));
    +}
    EXPORT_SYMBOL(ioread8);
    EXPORT_SYMBOL(ioread16);
    +EXPORT_SYMBOL(ioread16be);
    EXPORT_SYMBOL(ioread32);
    +EXPORT_SYMBOL(ioread32be);

    void fastcall iowrite8(u8 val, void __iomem *addr)
    {
    @@ -74,13 +84,23 @@
    {
    IO_COND(addr, outw(val,port), writew(val, addr));
    }
    +void fastcall iowrite16be(u16 val, void __iomem *addr)
    +{
    + IO_COND(addr, outw(val,port), __raw_writew(be16_to_cpu(val), addr));
    +}
    void fastcall iowrite32(u32 val, void __iomem *addr)
    {
    IO_COND(addr, outl(val,port), writel(val, addr));
    }
    +void fastcall iowrite32be(u32 val, void __iomem *addr)
    +{
    + IO_COND(addr, outl(val,port), __raw_writel(val, addr));
    +}
    EXPORT_SYMBOL(iowrite8);
    EXPORT_SYMBOL(iowrite16);
    +EXPORT_SYMBOL(iowrite16be);
    EXPORT_SYMBOL(iowrite32);
    +EXPORT_SYMBOL(iowrite32be);

    /*
    * These are the "repeat MMIO read/write" functions.

    -
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

    \
     
     \ /
      Last update: 2005-04-06 13:31    [W:0.032 / U:91.176 seconds]
    ©2003-2016 Jasper Spaans. hosted at Digital OceanAdvertise on this site