Patchwork fbmem: Fix fb_read, fb_write unaligned accesses.

login
register
mail settings
Submitter James Hogan
Date Sept. 18, 2010, 12:23 a.m.
Message ID <201009180123.48303.james@albanarts.com>
Download mbox | patch
Permalink /patch/65118/
State Not Applicable
Delegated to: David Miller
Headers show

Comments

James Hogan - Sept. 18, 2010, 12:23 a.m.
Apologies for corrupted patch. I'll try again.
Comments? I'd also appreciate if somebody familiar with sbus on sparc
could check this patch is sane since I know virtually nothing about sbus
and am not in a position to compile for sparc, let alone test on it:

fb_{read,write} access the framebuffer using lots of fb_{read,write}l's
but don't check that the file position is aligned which can cause
problems on some architectures which do not support unaligned accesses.

Since the operations are essentially memcpy_{from,to}io, new
fb_memcpy_{from,to}fb macros have been defined and these are used
instead.

For Sparc, fb_{read,write} macros use sbus_{read,write}, so this defines
new sbus_memcpy_{from,to}io functions the same as memcpy_{from,to}io but
using sbus_{read,write}b instead of {read,write}b.

Signed-off-by: James Hogan <james@albanarts.com>
---
 arch/sparc/include/asm/io_32.h |   31 +++++++++++++++++++++++++++
 arch/sparc/include/asm/io_64.h |   31 +++++++++++++++++++++++++++
 drivers/video/fbmem.c          |   46 ++++++++++++---------------------------
 include/linux/fb.h             |    6 +++++
 4 files changed, 82 insertions(+), 32 deletions(-)
David Miller - Sept. 18, 2010, 3:17 a.m.
From: James Hogan <james@albanarts.com>
Date: Sat, 18 Sep 2010 01:23:47 +0100

> Apologies for corrupted patch. I'll try again.
> Comments? I'd also appreciate if somebody familiar with sbus on sparc
> could check this patch is sane since I know virtually nothing about sbus
> and am not in a position to compile for sparc, let alone test on it:
> 
> fb_{read,write} access the framebuffer using lots of fb_{read,write}l's
> but don't check that the file position is aligned which can cause
> problems on some architectures which do not support unaligned accesses.
> 
> Since the operations are essentially memcpy_{from,to}io, new
> fb_memcpy_{from,to}fb macros have been defined and these are used
> instead.
> 
> For Sparc, fb_{read,write} macros use sbus_{read,write}, so this defines
> new sbus_memcpy_{from,to}io functions the same as memcpy_{from,to}io but
> using sbus_{read,write}b instead of {read,write}b.
> 
> Signed-off-by: James Hogan <james@albanarts.com>

Compiles cleanly on sparc and looks correct to me:

Acked-by: David S. Miller <davem@davemloft.net>
--
To unsubscribe from this list: send the line "unsubscribe sparclinux" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Florian Tobias Schandinat - Sept. 20, 2010, 7:27 p.m.
James Hogan schrieb:
> Apologies for corrupted patch. I'll try again.
> Comments? I'd also appreciate if somebody familiar with sbus on sparc
> could check this patch is sane since I know virtually nothing about sbus
> and am not in a position to compile for sparc, let alone test on it:
> 
> fb_{read,write} access the framebuffer using lots of fb_{read,write}l's
> but don't check that the file position is aligned which can cause
> problems on some architectures which do not support unaligned accesses.
> 
> Since the operations are essentially memcpy_{from,to}io, new
> fb_memcpy_{from,to}fb macros have been defined and these are used
> instead.
> 
> For Sparc, fb_{read,write} macros use sbus_{read,write}, so this defines
> new sbus_memcpy_{from,to}io functions the same as memcpy_{from,to}io but
> using sbus_{read,write}b instead of {read,write}b.
> 
> Signed-off-by: James Hogan <james@albanarts.com>

Looks correct and is an improvement.
I think it wouldn't be bad in terms of performance if we could avoid the double 
copy operation altogether but it might be overkill to add an 
fb_memcpy_{toio_from_user,fromio_to_user} just for that. But that's something 
that could be done in a later patch if anyone considers it worth the effort (I 
think most users just mmap the framebuffer anyway).

Acked-by: Florian Tobias Schandinat <FlorianSchandinat@gmx.de>

> ---
>  arch/sparc/include/asm/io_32.h |   31 +++++++++++++++++++++++++++
>  arch/sparc/include/asm/io_64.h |   31 +++++++++++++++++++++++++++
>  drivers/video/fbmem.c          |   46 ++++++++++++---------------------------
>  include/linux/fb.h             |    6 +++++
>  4 files changed, 82 insertions(+), 32 deletions(-)
> 
> diff --git a/arch/sparc/include/asm/io_32.h b/arch/sparc/include/asm/io_32.h
> index 2889574..c2ced21 100644
> --- a/arch/sparc/include/asm/io_32.h
> +++ b/arch/sparc/include/asm/io_32.h
> @@ -208,6 +208,21 @@ _memset_io(volatile void __iomem *dst, int c, __kernel_size_t n)
>  #define memset_io(d,c,sz)	_memset_io(d,c,sz)
>  
>  static inline void
> +_sbus_memcpy_fromio(void *dst, const volatile void __iomem *src,
> +		    __kernel_size_t n)
> +{
> +	char *d = dst;
> +
> +	while (n--) {
> +		char tmp = sbus_readb(src);
> +		*d++ = tmp;
> +		src++;
> +	}
> +}
> +
> +#define sbus_memcpy_fromio(d, s, sz)	_sbus_memcpy_fromio(d, s, sz)
> +
> +static inline void
>  _memcpy_fromio(void *dst, const volatile void __iomem *src, __kernel_size_t n)
>  {
>  	char *d = dst;
> @@ -222,6 +237,22 @@ _memcpy_fromio(void *dst, const volatile void __iomem *src, __kernel_size_t n)
>  #define memcpy_fromio(d,s,sz)	_memcpy_fromio(d,s,sz)
>  
>  static inline void
> +_sbus_memcpy_toio(volatile void __iomem *dst, const void *src,
> +		  __kernel_size_t n)
> +{
> +	const char *s = src;
> +	volatile void __iomem *d = dst;
> +
> +	while (n--) {
> +		char tmp = *s++;
> +		sbus_writeb(tmp, d);
> +		d++;
> +	}
> +}
> +
> +#define sbus_memcpy_toio(d, s, sz)	_sbus_memcpy_toio(d, s, sz)
> +
> +static inline void
>  _memcpy_toio(volatile void __iomem *dst, const void *src, __kernel_size_t n)
>  {
>  	const char *s = src;
> diff --git a/arch/sparc/include/asm/io_64.h b/arch/sparc/include/asm/io_64.h
> index 9517d06..9c89654 100644
> --- a/arch/sparc/include/asm/io_64.h
> +++ b/arch/sparc/include/asm/io_64.h
> @@ -419,6 +419,21 @@ _memset_io(volatile void __iomem *dst, int c, __kernel_size_t n)
>  #define memset_io(d,c,sz)	_memset_io(d,c,sz)
>  
>  static inline void
> +_sbus_memcpy_fromio(void *dst, const volatile void __iomem *src,
> +		    __kernel_size_t n)
> +{
> +	char *d = dst;
> +
> +	while (n--) {
> +		char tmp = sbus_readb(src);
> +		*d++ = tmp;
> +		src++;
> +	}
> +}
> +
> +#define sbus_memcpy_fromio(d, s, sz)	_sbus_memcpy_fromio(d, s, sz)
> +
> +static inline void
>  _memcpy_fromio(void *dst, const volatile void __iomem *src, __kernel_size_t n)
>  {
>  	char *d = dst;
> @@ -433,6 +448,22 @@ _memcpy_fromio(void *dst, const volatile void __iomem *src, __kernel_size_t n)
>  #define memcpy_fromio(d,s,sz)	_memcpy_fromio(d,s,sz)
>  
>  static inline void
> +_sbus_memcpy_toio(volatile void __iomem *dst, const void *src,
> +		  __kernel_size_t n)
> +{
> +	const char *s = src;
> +	volatile void __iomem *d = dst;
> +
> +	while (n--) {
> +		char tmp = *s++;
> +		sbus_writeb(tmp, d);
> +		d++;
> +	}
> +}
> +
> +#define sbus_memcpy_toio(d, s, sz)	_sbus_memcpy_toio(d, s, sz)
> +
> +static inline void
>  _memcpy_toio(volatile void __iomem *dst, const void *src, __kernel_size_t n)
>  {
>  	const char *s = src;
> diff --git a/drivers/video/fbmem.c b/drivers/video/fbmem.c
> index b066475..925f25d 100644
> --- a/drivers/video/fbmem.c
> +++ b/drivers/video/fbmem.c
> @@ -697,9 +697,9 @@ fb_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
>  	struct inode *inode = file->f_path.dentry->d_inode;
>  	int fbidx = iminor(inode);
>  	struct fb_info *info = registered_fb[fbidx];
> -	u32 *buffer, *dst;
> -	u32 __iomem *src;
> -	int c, i, cnt = 0, err = 0;
> +	u8 *buffer, *dst;
> +	u8 __iomem *src;
> +	int c, cnt = 0, err = 0;
>  	unsigned long total_size;
>  
>  	if (!info || ! info->screen_base)
> @@ -730,7 +730,7 @@ fb_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
>  	if (!buffer)
>  		return -ENOMEM;
>  
> -	src = (u32 __iomem *) (info->screen_base + p);
> +	src = (u8 __iomem *) (info->screen_base + p);
>  
>  	if (info->fbops->fb_sync)
>  		info->fbops->fb_sync(info);
> @@ -738,17 +738,9 @@ fb_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
>  	while (count) {
>  		c  = (count > PAGE_SIZE) ? PAGE_SIZE : count;
>  		dst = buffer;
> -		for (i = c >> 2; i--; )
> -			*dst++ = fb_readl(src++);
> -		if (c & 3) {
> -			u8 *dst8 = (u8 *) dst;
> -			u8 __iomem *src8 = (u8 __iomem *) src;
> -
> -			for (i = c & 3; i--;)
> -				*dst8++ = fb_readb(src8++);
> -
> -			src = (u32 __iomem *) src8;
> -		}
> +		fb_memcpy_fromfb(dst, src, c);
> +		dst += c;
> +		src += c;
>  
>  		if (copy_to_user(buf, buffer, c)) {
>  			err = -EFAULT;
> @@ -772,9 +764,9 @@ fb_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
>  	struct inode *inode = file->f_path.dentry->d_inode;
>  	int fbidx = iminor(inode);
>  	struct fb_info *info = registered_fb[fbidx];
> -	u32 *buffer, *src;
> -	u32 __iomem *dst;
> -	int c, i, cnt = 0, err = 0;
> +	u8 *buffer, *src;
> +	u8 __iomem *dst;
> +	int c, cnt = 0, err = 0;
>  	unsigned long total_size;
>  
>  	if (!info || !info->screen_base)
> @@ -811,7 +803,7 @@ fb_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
>  	if (!buffer)
>  		return -ENOMEM;
>  
> -	dst = (u32 __iomem *) (info->screen_base + p);
> +	dst = (u8 __iomem *) (info->screen_base + p);
>  
>  	if (info->fbops->fb_sync)
>  		info->fbops->fb_sync(info);
> @@ -825,19 +817,9 @@ fb_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
>  			break;
>  		}
>  
> -		for (i = c >> 2; i--; )
> -			fb_writel(*src++, dst++);
> -
> -		if (c & 3) {
> -			u8 *src8 = (u8 *) src;
> -			u8 __iomem *dst8 = (u8 __iomem *) dst;
> -
> -			for (i = c & 3; i--; )
> -				fb_writeb(*src8++, dst8++);
> -
> -			dst = (u32 __iomem *) dst8;
> -		}
> -
> +		fb_memcpy_tofb(dst, src, c);
> +		dst += c;
> +		src += c;
>  		*ppos += c;
>  		buf += c;
>  		cnt += c;
> diff --git a/include/linux/fb.h b/include/linux/fb.h
> index f0268de..7fca3dc 100644
> --- a/include/linux/fb.h
> +++ b/include/linux/fb.h
> @@ -931,6 +931,8 @@ static inline struct apertures_struct *alloc_apertures(unsigned int max_num) {
>  #define fb_writel sbus_writel
>  #define fb_writeq sbus_writeq
>  #define fb_memset sbus_memset_io
> +#define fb_memcpy_fromfb sbus_memcpy_fromio
> +#define fb_memcpy_tofb sbus_memcpy_toio
>  
>  #elif defined(__i386__) || defined(__alpha__) || defined(__x86_64__) || defined(__hppa__) || defined(__sh__) || defined(__powerpc__) || defined(__avr32__) || defined(__bfin__)
>  
> @@ -943,6 +945,8 @@ static inline struct apertures_struct *alloc_apertures(unsigned int max_num) {
>  #define fb_writel __raw_writel
>  #define fb_writeq __raw_writeq
>  #define fb_memset memset_io
> +#define fb_memcpy_fromfb memcpy_fromio
> +#define fb_memcpy_tofb memcpy_toio
>  
>  #else
>  
> @@ -955,6 +959,8 @@ static inline struct apertures_struct *alloc_apertures(unsigned int max_num) {
>  #define fb_writel(b,addr) (*(volatile u32 *) (addr) = (b))
>  #define fb_writeq(b,addr) (*(volatile u64 *) (addr) = (b))
>  #define fb_memset memset
> +#define fb_memcpy_fromfb memcpy
> +#define fb_memcpy_tofb memcpy
>  
>  #endif
>  

--
To unsubscribe from this list: send the line "unsubscribe sparclinux" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Andrew Morton - Sept. 21, 2010, 11:19 p.m.
On Sat, 18 Sep 2010 01:23:47 +0100
James Hogan <james@albanarts.com> wrote:

> Apologies for corrupted patch. I'll try again.
> Comments? I'd also appreciate if somebody familiar with sbus on sparc
> could check this patch is sane since I know virtually nothing about sbus
> and am not in a position to compile for sparc, let alone test on it:
> 
> fb_{read,write} access the framebuffer using lots of fb_{read,write}l's
> but don't check that the file position is aligned which can cause
> problems on some architectures which do not support unaligned accesses.

What are these "problems"?

I'd have thought they would be fairly fatal, in which case this is a
high-priority patch.  But I'd also have thought that the problems would
have been noted before now.

So I assume that you're doing something which nobody has done before.

Confused.  Help?

> Since the operations are essentially memcpy_{from,to}io, new
> fb_memcpy_{from,to}fb macros have been defined and these are used
> instead.
> 
> For Sparc, fb_{read,write} macros use sbus_{read,write}, so this defines
> new sbus_memcpy_{from,to}io functions the same as memcpy_{from,to}io but
> using sbus_{read,write}b instead of {read,write}b.
--
To unsubscribe from this list: send the line "unsubscribe sparclinux" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
James Hogan - Sept. 22, 2010, midnight
On Wednesday 22 September 2010 00:19:50 Andrew Morton wrote:
> On Sat, 18 Sep 2010 01:23:47 +0100
> 
> James Hogan <james@albanarts.com> wrote:
> > Apologies for corrupted patch. I'll try again.
> > Comments? I'd also appreciate if somebody familiar with sbus on sparc
> > could check this patch is sane since I know virtually nothing about sbus
> > and am not in a position to compile for sparc, let alone test on it:
> > 
> > fb_{read,write} access the framebuffer using lots of fb_{read,write}l's
> > but don't check that the file position is aligned which can cause
> > problems on some architectures which do not support unaligned accesses.
> 
> What are these "problems"?

On the arch I hit this on (which isn't in tree) I experienced a fault at the 
point of the unaligned write in kernel code, but this is only because 
unaligned access checking is switched on which isn't always possible 
(otherwise the write would have just silently failed/done something else). It 
terminated the program, but didn't cause any other problems.
Documentation/unaligned-memory-access.txt also mentions that some 
architectures raise exceptions that can't be worked around, or fail silently 
and may actually perform different writes to the one requested.

> I'd have thought they would be fairly fatal, in which case this is a
> high-priority patch.  But I'd also have thought that the problems would
> have been noted before now.

The common way to access the framebuffer is by mmapping it into userland, so I 
don't think the read/write syscalls are commonly used on it, and in any case 
colour data tends to be naturally aligned so unaligned writes would be 
uncommon.

> 
> So I assume that you're doing something which nobody has done before.
> 
> Confused.  Help?

The actualy case that hit this is admitedly rather silly. I did a quick test 
of the framebuffer by typing this at a shell:
yes > /dev/fb0
I'd have to check it again to see exactly how lots of 2 byte writes ("y\n") 
ended up unaligned, but at the point of the crash the dest pointer was 
definitely unaligned (the hex address ended in a 5) and the patch fixed it for 
me.

Hope that helps.

Cheers
James

Patch

diff --git a/arch/sparc/include/asm/io_32.h b/arch/sparc/include/asm/io_32.h
index 2889574..c2ced21 100644
--- a/arch/sparc/include/asm/io_32.h
+++ b/arch/sparc/include/asm/io_32.h
@@ -208,6 +208,21 @@  _memset_io(volatile void __iomem *dst, int c, __kernel_size_t n)
 #define memset_io(d,c,sz)	_memset_io(d,c,sz)
 
 static inline void
+_sbus_memcpy_fromio(void *dst, const volatile void __iomem *src,
+		    __kernel_size_t n)
+{
+	char *d = dst;
+
+	while (n--) {
+		char tmp = sbus_readb(src);
+		*d++ = tmp;
+		src++;
+	}
+}
+
+#define sbus_memcpy_fromio(d, s, sz)	_sbus_memcpy_fromio(d, s, sz)
+
+static inline void
 _memcpy_fromio(void *dst, const volatile void __iomem *src, __kernel_size_t n)
 {
 	char *d = dst;
@@ -222,6 +237,22 @@  _memcpy_fromio(void *dst, const volatile void __iomem *src, __kernel_size_t n)
 #define memcpy_fromio(d,s,sz)	_memcpy_fromio(d,s,sz)
 
 static inline void
+_sbus_memcpy_toio(volatile void __iomem *dst, const void *src,
+		  __kernel_size_t n)
+{
+	const char *s = src;
+	volatile void __iomem *d = dst;
+
+	while (n--) {
+		char tmp = *s++;
+		sbus_writeb(tmp, d);
+		d++;
+	}
+}
+
+#define sbus_memcpy_toio(d, s, sz)	_sbus_memcpy_toio(d, s, sz)
+
+static inline void
 _memcpy_toio(volatile void __iomem *dst, const void *src, __kernel_size_t n)
 {
 	const char *s = src;
diff --git a/arch/sparc/include/asm/io_64.h b/arch/sparc/include/asm/io_64.h
index 9517d06..9c89654 100644
--- a/arch/sparc/include/asm/io_64.h
+++ b/arch/sparc/include/asm/io_64.h
@@ -419,6 +419,21 @@  _memset_io(volatile void __iomem *dst, int c, __kernel_size_t n)
 #define memset_io(d,c,sz)	_memset_io(d,c,sz)
 
 static inline void
+_sbus_memcpy_fromio(void *dst, const volatile void __iomem *src,
+		    __kernel_size_t n)
+{
+	char *d = dst;
+
+	while (n--) {
+		char tmp = sbus_readb(src);
+		*d++ = tmp;
+		src++;
+	}
+}
+
+#define sbus_memcpy_fromio(d, s, sz)	_sbus_memcpy_fromio(d, s, sz)
+
+static inline void
 _memcpy_fromio(void *dst, const volatile void __iomem *src, __kernel_size_t n)
 {
 	char *d = dst;
@@ -433,6 +448,22 @@  _memcpy_fromio(void *dst, const volatile void __iomem *src, __kernel_size_t n)
 #define memcpy_fromio(d,s,sz)	_memcpy_fromio(d,s,sz)
 
 static inline void
+_sbus_memcpy_toio(volatile void __iomem *dst, const void *src,
+		  __kernel_size_t n)
+{
+	const char *s = src;
+	volatile void __iomem *d = dst;
+
+	while (n--) {
+		char tmp = *s++;
+		sbus_writeb(tmp, d);
+		d++;
+	}
+}
+
+#define sbus_memcpy_toio(d, s, sz)	_sbus_memcpy_toio(d, s, sz)
+
+static inline void
 _memcpy_toio(volatile void __iomem *dst, const void *src, __kernel_size_t n)
 {
 	const char *s = src;
diff --git a/drivers/video/fbmem.c b/drivers/video/fbmem.c
index b066475..925f25d 100644
--- a/drivers/video/fbmem.c
+++ b/drivers/video/fbmem.c
@@ -697,9 +697,9 @@  fb_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
 	struct inode *inode = file->f_path.dentry->d_inode;
 	int fbidx = iminor(inode);
 	struct fb_info *info = registered_fb[fbidx];
-	u32 *buffer, *dst;
-	u32 __iomem *src;
-	int c, i, cnt = 0, err = 0;
+	u8 *buffer, *dst;
+	u8 __iomem *src;
+	int c, cnt = 0, err = 0;
 	unsigned long total_size;
 
 	if (!info || ! info->screen_base)
@@ -730,7 +730,7 @@  fb_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
 	if (!buffer)
 		return -ENOMEM;
 
-	src = (u32 __iomem *) (info->screen_base + p);
+	src = (u8 __iomem *) (info->screen_base + p);
 
 	if (info->fbops->fb_sync)
 		info->fbops->fb_sync(info);
@@ -738,17 +738,9 @@  fb_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
 	while (count) {
 		c  = (count > PAGE_SIZE) ? PAGE_SIZE : count;
 		dst = buffer;
-		for (i = c >> 2; i--; )
-			*dst++ = fb_readl(src++);
-		if (c & 3) {
-			u8 *dst8 = (u8 *) dst;
-			u8 __iomem *src8 = (u8 __iomem *) src;
-
-			for (i = c & 3; i--;)
-				*dst8++ = fb_readb(src8++);
-
-			src = (u32 __iomem *) src8;
-		}
+		fb_memcpy_fromfb(dst, src, c);
+		dst += c;
+		src += c;
 
 		if (copy_to_user(buf, buffer, c)) {
 			err = -EFAULT;
@@ -772,9 +764,9 @@  fb_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
 	struct inode *inode = file->f_path.dentry->d_inode;
 	int fbidx = iminor(inode);
 	struct fb_info *info = registered_fb[fbidx];
-	u32 *buffer, *src;
-	u32 __iomem *dst;
-	int c, i, cnt = 0, err = 0;
+	u8 *buffer, *src;
+	u8 __iomem *dst;
+	int c, cnt = 0, err = 0;
 	unsigned long total_size;
 
 	if (!info || !info->screen_base)
@@ -811,7 +803,7 @@  fb_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
 	if (!buffer)
 		return -ENOMEM;
 
-	dst = (u32 __iomem *) (info->screen_base + p);
+	dst = (u8 __iomem *) (info->screen_base + p);
 
 	if (info->fbops->fb_sync)
 		info->fbops->fb_sync(info);
@@ -825,19 +817,9 @@  fb_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
 			break;
 		}
 
-		for (i = c >> 2; i--; )
-			fb_writel(*src++, dst++);
-
-		if (c & 3) {
-			u8 *src8 = (u8 *) src;
-			u8 __iomem *dst8 = (u8 __iomem *) dst;
-
-			for (i = c & 3; i--; )
-				fb_writeb(*src8++, dst8++);
-
-			dst = (u32 __iomem *) dst8;
-		}
-
+		fb_memcpy_tofb(dst, src, c);
+		dst += c;
+		src += c;
 		*ppos += c;
 		buf += c;
 		cnt += c;
diff --git a/include/linux/fb.h b/include/linux/fb.h
index f0268de..7fca3dc 100644
--- a/include/linux/fb.h
+++ b/include/linux/fb.h
@@ -931,6 +931,8 @@  static inline struct apertures_struct *alloc_apertures(unsigned int max_num) {
 #define fb_writel sbus_writel
 #define fb_writeq sbus_writeq
 #define fb_memset sbus_memset_io
+#define fb_memcpy_fromfb sbus_memcpy_fromio
+#define fb_memcpy_tofb sbus_memcpy_toio
 
 #elif defined(__i386__) || defined(__alpha__) || defined(__x86_64__) || defined(__hppa__) || defined(__sh__) || defined(__powerpc__) || defined(__avr32__) || defined(__bfin__)
 
@@ -943,6 +945,8 @@  static inline struct apertures_struct *alloc_apertures(unsigned int max_num) {
 #define fb_writel __raw_writel
 #define fb_writeq __raw_writeq
 #define fb_memset memset_io
+#define fb_memcpy_fromfb memcpy_fromio
+#define fb_memcpy_tofb memcpy_toio
 
 #else
 
@@ -955,6 +959,8 @@  static inline struct apertures_struct *alloc_apertures(unsigned int max_num) {
 #define fb_writel(b,addr) (*(volatile u32 *) (addr) = (b))
 #define fb_writeq(b,addr) (*(volatile u64 *) (addr) = (b))
 #define fb_memset memset
+#define fb_memcpy_fromfb memcpy
+#define fb_memcpy_tofb memcpy
 
 #endif