1 files changed, 47 insertions, 92 deletions
diff --git a/arch/sparc64/lib/PeeCeeI.c b/arch/sparc64/lib/PeeCeeI.c
index 8b313f11bc8..46053e6ddd7 100644
--- a/arch/sparc64/lib/PeeCeeI.c
+++ b/arch/sparc64/lib/PeeCeeI.c
@@ -20,107 +20,62 @@ void outsw(unsigned long __addr, const void *src, unsigned long count)
 {
        void __iomem *addr = (void __iomem *) __addr;
-        if (count) {
+        while (count--) {
-                u16 *ps = (u16 *)src;
+                __raw_writew(*(u16 *)src, addr);
-                u32 *pi;
+                src += sizeof(u16);
-                if (((u64)src) & 0x2) {
-                        u16 val = le16_to_cpup(ps);
-                        outw(val, addr);
-                        ps++;
-                        count--;
-                }
-                pi = (u32 *)ps;
-                while (count >= 2) {
-                        u32 w = le32_to_cpup(pi);
-                        pi++;
-                        outw(w >> 0, addr);
-                        outw(w >> 16, addr);
-                        count -= 2;
-                }
-                ps = (u16 *)pi;
-                if (count) {
-                        u16 val = le16_to_cpup(ps);
-                        outw(val, addr);
-                }
        }
 }
 void outsl(unsigned long __addr, const void *src, unsigned long count)
 {
        void __iomem *addr = (void __iomem *) __addr;
+        u32 l, l2;
-        if (count) {
+        if (!count)
-                if ((((u64)src) & 0x3) == 0) {
+                return;
-                        u32 *p = (u32 *)src;
-                        while (count--) {
-                                u32 val = cpu_to_le32p(p);
-                                outl(val, addr);
-                                p++;
-                        }
-                } else {
-                        u8 *pb;
-                        u16 *ps = (u16 *)src;
-                        u32 l = 0, l2;
-                        u32 *pi;
-                        switch (((u64)src) & 0x3) {
-                        case 0x2:
-                                count -= 1;
-                                l = cpu_to_le16p(ps) << 16;
-                                ps++;
-                                pi = (u32 *)ps;
-                                while (count--) {
-                                        l2 = cpu_to_le32p(pi);
-                                        pi++;
-                                        outl(((l >> 16) | (l2 << 16)), addr);
-                                        l = l2;
-                                }
-                                ps = (u16 *)pi;
-                                l2 = cpu_to_le16p(ps);
-                                outl(((l >> 16) | (l2 << 16)), addr);
-                                break;
-                        case 0x1:
-                                count -= 1;
-                                pb = (u8 *)src;
-                                l = (*pb++ << 8);
-                                ps = (u16 *)pb;
-                                l2 = cpu_to_le16p(ps);
-                                ps++;
-                                l |= (l2 << 16);
-                                pi = (u32 *)ps;
-                                while (count--) {
-                                        l2 = cpu_to_le32p(pi);
-                                        pi++;
-                                        outl(((l >> 8) | (l2 << 24)), addr);
-                                        l = l2;
-                                }
-                                pb = (u8 *)pi;
-                                outl(((l >> 8) | (*pb << 24)), addr);
-                                break;
-                        case 0x3:
+        switch (((unsigned long)src) & 0x3) {
-                                count -= 1;
+        case 0x0:
-                                pb = (u8 *)src;
+                /* src is naturally aligned */
-                                l = (*pb++ << 24);
+                while (count--) {
-                                pi = (u32 *)pb;
+                        __raw_writel(*(u32 *)src, addr);
-                                while (count--) {
+                        src += sizeof(u32);
-                                        l2 = cpu_to_le32p(pi);
+                }
-                                        pi++;
+                break;
-                                        outl(((l >> 24) | (l2 << 8)), addr);
+        case 0x2:
-                                        l = l2;
+                /* 2-byte alignment */
-                                }
+                while (count--) {
-                                ps = (u16 *)pi;
+                        l = (*(u16 *)src) << 16;
-                                l2 = cpu_to_le16p(ps);
+                        l |= *(u16 *)(src + sizeof(u16));
-                                ps++;
+                        __raw_writel(l, addr);
-                                pb = (u8 *)ps;
+                        src += sizeof(u32);
-                                l2 |= (*pb << 16);
+                }
-                                outl(((l >> 24) | (l2 << 8)), addr);
+                break;
-                                break;
+        case 0x1:
-                        }
+                /* Hold three bytes in l each time, grab a byte from l2 */
+                l = (*(u8 *)src) << 24;
+                l |= (*(u16 *)(src + sizeof(u8))) << 8;
+                src += sizeof(u8) + sizeof(u16);
+                while (count--) {
+                        l2 = *(u32 *)src;
+                        l |= (l2 >> 24);
+                        __raw_writel(l, addr);
+                        l = l2 << 8;
+                        src += sizeof(u32);
+                }
+                break;
+        case 0x3:
+                /* Hold a byte in l each time, grab 3 bytes from l2 */
+                l = (*(u8 *)src) << 24;
+                src += sizeof(u8);
+                while (count--) {
+                        l2 = *(u32 *)src;
+                        l |= (l2 >> 8);
+                        __raw_writel(l, addr);
+                        l = l2 << 24;
+                        src += sizeof(u32);
                }
+                break;
        }
 }

diff --git a/arch/sparc64/lib/PeeCeeI.c b/arch/sparc64/lib/PeeCeeI.c index 8b313f11bc8..46053e6ddd7 100644 --- a/arch/sparc64/lib/PeeCeeI.c +++ b/arch/sparc64/lib/PeeCeeI.c
@@ -20,107 +20,62 @@ void outsw(unsigned long __addr, const void *src, unsigned long count)
20	{	20	{
21	void __iomem addr = (void __iomem ) __addr;	21	void __iomem addr = (void __iomem ) __addr;
22		22
23	if (count) {	23	while (count--) {
24	u16 ps = (u16 )src;	24	__raw_writew((u16 )src, addr);
25	u32 *pi;	25	src += sizeof(u16);
26
27	if (((u64)src) & 0x2) {
28	u16 val = le16_to_cpup(ps);
29	outw(val, addr);
30	ps++;
31	count--;
32	}
33	pi = (u32 *)ps;
34	while (count >= 2) {
35	u32 w = le32_to_cpup(pi);
36
37	pi++;
38	outw(w >> 0, addr);
39	outw(w >> 16, addr);
40	count -= 2;
41	}
42	ps = (u16 *)pi;
43	if (count) {
44	u16 val = le16_to_cpup(ps);
45	outw(val, addr);
46	}
47	}	26	}
48	}	27	}
49		28
50	void outsl(unsigned long __addr, const void *src, unsigned long count)	29	void outsl(unsigned long __addr, const void *src, unsigned long count)
51	{	30	{
52	void __iomem addr = (void __iomem ) __addr;	31	void __iomem addr = (void __iomem ) __addr;
		32	u32 l, l2;
53		33
54	if (count) {	34	if (!count)
55	if ((((u64)src) & 0x3) == 0) {	35	return;
56	u32 p = (u32 )src;
57	while (count--) {
58	u32 val = cpu_to_le32p(p);
59	outl(val, addr);
60	p++;
61	}
62	} else {
63	u8 *pb;
64	u16 ps = (u16 )src;
65	u32 l = 0, l2;
66	u32 *pi;
67
68	switch (((u64)src) & 0x3) {
69	case 0x2:
70	count -= 1;
71	l = cpu_to_le16p(ps) << 16;
72	ps++;
73	pi = (u32 *)ps;
74	while (count--) {
75	l2 = cpu_to_le32p(pi);
76	pi++;
77	outl(((l >> 16) \| (l2 << 16)), addr);
78	l = l2;
79	}
80	ps = (u16 *)pi;
81	l2 = cpu_to_le16p(ps);
82	outl(((l >> 16) \| (l2 << 16)), addr);
83	break;
84
85	case 0x1:
86	count -= 1;
87	pb = (u8 *)src;
88	l = (*pb++ << 8);
89	ps = (u16 *)pb;
90	l2 = cpu_to_le16p(ps);
91	ps++;
92	l \|= (l2 << 16);
93	pi = (u32 *)ps;
94	while (count--) {
95	l2 = cpu_to_le32p(pi);
96	pi++;
97	outl(((l >> 8) \| (l2 << 24)), addr);
98	l = l2;
99	}
100	pb = (u8 *)pi;
101	outl(((l >> 8) \| (*pb << 24)), addr);
102	break;
103		36
104	case 0x3:	37	switch (((unsigned long)src) & 0x3) {
105	count -= 1;	38	case 0x0:
106	pb = (u8 *)src;	39	/* src is naturally aligned */
107	l = (*pb++ << 24);	40	while (count--) {
108	pi = (u32 *)pb;	41	__raw_writel((u32 )src, addr);
109	while (count--) {	42	src += sizeof(u32);
110	l2 = cpu_to_le32p(pi);	43	}
111	pi++;	44	break;
112	outl(((l >> 24) \| (l2 << 8)), addr);	45	case 0x2:
113	l = l2;	46	/* 2-byte alignment */
114	}	47	while (count--) {
115	ps = (u16 *)pi;	48	l = ((u16 )src) << 16;
116	l2 = cpu_to_le16p(ps);	49	l \|= (u16 )(src + sizeof(u16));
117	ps++;	50	__raw_writel(l, addr);
118	pb = (u8 *)ps;	51	src += sizeof(u32);
119	l2 \|= (*pb << 16);	52	}
120	outl(((l >> 24) \| (l2 << 8)), addr);	53	break;
121	break;	54	case 0x1:
122	}	55	/* Hold three bytes in l each time, grab a byte from l2 */
		56	l = ((u8 )src) << 24;
		57	l \|= ((u16 )(src + sizeof(u8))) << 8;
		58	src += sizeof(u8) + sizeof(u16);
		59	while (count--) {
		60	l2 = (u32 )src;
		61	l \|= (l2 >> 24);
		62	__raw_writel(l, addr);
		63	l = l2 << 8;
		64	src += sizeof(u32);
		65	}
		66	break;
		67	case 0x3:
		68	/* Hold a byte in l each time, grab 3 bytes from l2 */
		69	l = ((u8 )src) << 24;
		70	src += sizeof(u8);
		71	while (count--) {
		72	l2 = (u32 )src;
		73	l \|= (l2 >> 8);
		74	__raw_writel(l, addr);
		75	l = l2 << 24;
		76	src += sizeof(u32);
123	}	77	}
		78	break;
124	}	79	}
125	}	80	}
126		81