forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
489 lines
9.8 KiB
489 lines
9.8 KiB
// SPDX-License-Identifier: GPL-2.0 |
|
/* |
|
* arch/parisc/lib/io.c |
|
* |
|
* Copyright (c) Matthew Wilcox 2001 for Hewlett-Packard |
|
* Copyright (c) Randolph Chung 2001 <[email protected]> |
|
* |
|
* IO accessing functions which shouldn't be inlined because they're too big |
|
*/ |
|
|
|
#include <linux/kernel.h> |
|
#include <linux/module.h> |
|
#include <asm/io.h> |
|
|
|
/* Copies a block of memory to a device in an efficient manner. |
|
* Assumes the device can cope with 32-bit transfers. If it can't, |
|
* don't use this function. |
|
*/ |
|
void memcpy_toio(volatile void __iomem *dst, const void *src, int count) |
|
{ |
|
if (((unsigned long)dst & 3) != ((unsigned long)src & 3)) |
|
goto bytecopy; |
|
while ((unsigned long)dst & 3) { |
|
writeb(*(char *)src, dst++); |
|
src++; |
|
count--; |
|
} |
|
while (count > 3) { |
|
__raw_writel(*(u32 *)src, dst); |
|
src += 4; |
|
dst += 4; |
|
count -= 4; |
|
} |
|
bytecopy: |
|
while (count--) { |
|
writeb(*(char *)src, dst++); |
|
src++; |
|
} |
|
} |
|
|
|
/* |
|
** Copies a block of memory from a device in an efficient manner. |
|
** Assumes the device can cope with 32-bit transfers. If it can't, |
|
** don't use this function. |
|
** |
|
** CR16 counts on C3000 reading 256 bytes from Symbios 896 RAM: |
|
** 27341/64 = 427 cyc per int |
|
** 61311/128 = 478 cyc per short |
|
** 122637/256 = 479 cyc per byte |
|
** Ergo bus latencies dominant (not transfer size). |
|
** Minimize total number of transfers at cost of CPU cycles. |
|
** TODO: only look at src alignment and adjust the stores to dest. |
|
*/ |
|
void memcpy_fromio(void *dst, const volatile void __iomem *src, int count) |
|
{ |
|
/* first compare alignment of src/dst */ |
|
if ( (((unsigned long)dst ^ (unsigned long)src) & 1) || (count < 2) ) |
|
goto bytecopy; |
|
|
|
if ( (((unsigned long)dst ^ (unsigned long)src) & 2) || (count < 4) ) |
|
goto shortcopy; |
|
|
|
/* Then check for misaligned start address */ |
|
if ((unsigned long)src & 1) { |
|
*(u8 *)dst = readb(src); |
|
src++; |
|
dst++; |
|
count--; |
|
if (count < 2) goto bytecopy; |
|
} |
|
|
|
if ((unsigned long)src & 2) { |
|
*(u16 *)dst = __raw_readw(src); |
|
src += 2; |
|
dst += 2; |
|
count -= 2; |
|
} |
|
|
|
while (count > 3) { |
|
*(u32 *)dst = __raw_readl(src); |
|
dst += 4; |
|
src += 4; |
|
count -= 4; |
|
} |
|
|
|
shortcopy: |
|
while (count > 1) { |
|
*(u16 *)dst = __raw_readw(src); |
|
src += 2; |
|
dst += 2; |
|
count -= 2; |
|
} |
|
|
|
bytecopy: |
|
while (count--) { |
|
*(char *)dst = readb(src); |
|
src++; |
|
dst++; |
|
} |
|
} |
|
|
|
/* Sets a block of memory on a device to a given value. |
|
* Assumes the device can cope with 32-bit transfers. If it can't, |
|
* don't use this function. |
|
*/ |
|
void memset_io(volatile void __iomem *addr, unsigned char val, int count) |
|
{ |
|
u32 val32 = (val << 24) | (val << 16) | (val << 8) | val; |
|
while ((unsigned long)addr & 3) { |
|
writeb(val, addr++); |
|
count--; |
|
} |
|
while (count > 3) { |
|
__raw_writel(val32, addr); |
|
addr += 4; |
|
count -= 4; |
|
} |
|
while (count--) { |
|
writeb(val, addr++); |
|
} |
|
} |
|
|
|
/* |
|
* Read COUNT 8-bit bytes from port PORT into memory starting at |
|
* SRC. |
|
*/ |
|
void insb (unsigned long port, void *dst, unsigned long count) |
|
{ |
|
unsigned char *p; |
|
|
|
p = (unsigned char *)dst; |
|
|
|
while (((unsigned long)p) & 0x3) { |
|
if (!count) |
|
return; |
|
count--; |
|
*p = inb(port); |
|
p++; |
|
} |
|
|
|
while (count >= 4) { |
|
unsigned int w; |
|
count -= 4; |
|
w = inb(port) << 24; |
|
w |= inb(port) << 16; |
|
w |= inb(port) << 8; |
|
w |= inb(port); |
|
*(unsigned int *) p = w; |
|
p += 4; |
|
} |
|
|
|
while (count) { |
|
--count; |
|
*p = inb(port); |
|
p++; |
|
} |
|
} |
|
|
|
|
|
/* |
|
* Read COUNT 16-bit words from port PORT into memory starting at |
|
* SRC. SRC must be at least short aligned. This is used by the |
|
* IDE driver to read disk sectors. Performance is important, but |
|
* the interfaces seems to be slow: just using the inlined version |
|
* of the inw() breaks things. |
|
*/ |
|
void insw (unsigned long port, void *dst, unsigned long count) |
|
{ |
|
unsigned int l = 0, l2; |
|
unsigned char *p; |
|
|
|
p = (unsigned char *)dst; |
|
|
|
if (!count) |
|
return; |
|
|
|
switch (((unsigned long)p) & 0x3) |
|
{ |
|
case 0x00: /* Buffer 32-bit aligned */ |
|
while (count>=2) { |
|
|
|
count -= 2; |
|
l = cpu_to_le16(inw(port)) << 16; |
|
l |= cpu_to_le16(inw(port)); |
|
*(unsigned int *)p = l; |
|
p += 4; |
|
} |
|
if (count) { |
|
*(unsigned short *)p = cpu_to_le16(inw(port)); |
|
} |
|
break; |
|
|
|
case 0x02: /* Buffer 16-bit aligned */ |
|
*(unsigned short *)p = cpu_to_le16(inw(port)); |
|
p += 2; |
|
count--; |
|
while (count>=2) { |
|
|
|
count -= 2; |
|
l = cpu_to_le16(inw(port)) << 16; |
|
l |= cpu_to_le16(inw(port)); |
|
*(unsigned int *)p = l; |
|
p += 4; |
|
} |
|
if (count) { |
|
*(unsigned short *)p = cpu_to_le16(inw(port)); |
|
} |
|
break; |
|
|
|
case 0x01: /* Buffer 8-bit aligned */ |
|
case 0x03: |
|
/* I don't bother with 32bit transfers |
|
* in this case, 16bit will have to do -- DE */ |
|
--count; |
|
|
|
l = cpu_to_le16(inw(port)); |
|
*p = l >> 8; |
|
p++; |
|
while (count--) |
|
{ |
|
l2 = cpu_to_le16(inw(port)); |
|
*(unsigned short *)p = (l & 0xff) << 8 | (l2 >> 8); |
|
p += 2; |
|
l = l2; |
|
} |
|
*p = l & 0xff; |
|
break; |
|
} |
|
} |
|
|
|
|
|
|
|
/* |
|
* Read COUNT 32-bit words from port PORT into memory starting at |
|
* SRC. Now works with any alignment in SRC. Performance is important, |
|
* but the interfaces seems to be slow: just using the inlined version |
|
* of the inl() breaks things. |
|
*/ |
|
void insl (unsigned long port, void *dst, unsigned long count) |
|
{ |
|
unsigned int l = 0, l2; |
|
unsigned char *p; |
|
|
|
p = (unsigned char *)dst; |
|
|
|
if (!count) |
|
return; |
|
|
|
switch (((unsigned long) dst) & 0x3) |
|
{ |
|
case 0x00: /* Buffer 32-bit aligned */ |
|
while (count--) |
|
{ |
|
*(unsigned int *)p = cpu_to_le32(inl(port)); |
|
p += 4; |
|
} |
|
break; |
|
|
|
case 0x02: /* Buffer 16-bit aligned */ |
|
--count; |
|
|
|
l = cpu_to_le32(inl(port)); |
|
*(unsigned short *)p = l >> 16; |
|
p += 2; |
|
|
|
while (count--) |
|
{ |
|
l2 = cpu_to_le32(inl(port)); |
|
*(unsigned int *)p = (l & 0xffff) << 16 | (l2 >> 16); |
|
p += 4; |
|
l = l2; |
|
} |
|
*(unsigned short *)p = l & 0xffff; |
|
break; |
|
case 0x01: /* Buffer 8-bit aligned */ |
|
--count; |
|
|
|
l = cpu_to_le32(inl(port)); |
|
*(unsigned char *)p = l >> 24; |
|
p++; |
|
*(unsigned short *)p = (l >> 8) & 0xffff; |
|
p += 2; |
|
while (count--) |
|
{ |
|
l2 = cpu_to_le32(inl(port)); |
|
*(unsigned int *)p = (l & 0xff) << 24 | (l2 >> 8); |
|
p += 4; |
|
l = l2; |
|
} |
|
*p = l & 0xff; |
|
break; |
|
case 0x03: /* Buffer 8-bit aligned */ |
|
--count; |
|
|
|
l = cpu_to_le32(inl(port)); |
|
*p = l >> 24; |
|
p++; |
|
while (count--) |
|
{ |
|
l2 = cpu_to_le32(inl(port)); |
|
*(unsigned int *)p = (l & 0xffffff) << 8 | l2 >> 24; |
|
p += 4; |
|
l = l2; |
|
} |
|
*(unsigned short *)p = (l >> 8) & 0xffff; |
|
p += 2; |
|
*p = l & 0xff; |
|
break; |
|
} |
|
} |
|
|
|
|
|
/* |
|
* Like insb but in the opposite direction. |
|
* Don't worry as much about doing aligned memory transfers: |
|
* doing byte reads the "slow" way isn't nearly as slow as |
|
* doing byte writes the slow way (no r-m-w cycle). |
|
*/ |
|
void outsb(unsigned long port, const void * src, unsigned long count) |
|
{ |
|
const unsigned char *p; |
|
|
|
p = (const unsigned char *)src; |
|
while (count) { |
|
count--; |
|
outb(*p, port); |
|
p++; |
|
} |
|
} |
|
|
|
/* |
|
* Like insw but in the opposite direction. This is used by the IDE |
|
* driver to write disk sectors. Performance is important, but the |
|
* interfaces seems to be slow: just using the inlined version of the |
|
* outw() breaks things. |
|
*/ |
|
void outsw (unsigned long port, const void *src, unsigned long count) |
|
{ |
|
unsigned int l = 0, l2; |
|
const unsigned char *p; |
|
|
|
p = (const unsigned char *)src; |
|
|
|
if (!count) |
|
return; |
|
|
|
switch (((unsigned long)p) & 0x3) |
|
{ |
|
case 0x00: /* Buffer 32-bit aligned */ |
|
while (count>=2) { |
|
count -= 2; |
|
l = *(unsigned int *)p; |
|
p += 4; |
|
outw(le16_to_cpu(l >> 16), port); |
|
outw(le16_to_cpu(l & 0xffff), port); |
|
} |
|
if (count) { |
|
outw(le16_to_cpu(*(unsigned short*)p), port); |
|
} |
|
break; |
|
|
|
case 0x02: /* Buffer 16-bit aligned */ |
|
|
|
outw(le16_to_cpu(*(unsigned short*)p), port); |
|
p += 2; |
|
count--; |
|
|
|
while (count>=2) { |
|
count -= 2; |
|
l = *(unsigned int *)p; |
|
p += 4; |
|
outw(le16_to_cpu(l >> 16), port); |
|
outw(le16_to_cpu(l & 0xffff), port); |
|
} |
|
if (count) { |
|
outw(le16_to_cpu(*(unsigned short *)p), port); |
|
} |
|
break; |
|
|
|
case 0x01: /* Buffer 8-bit aligned */ |
|
/* I don't bother with 32bit transfers |
|
* in this case, 16bit will have to do -- DE */ |
|
|
|
l = *p << 8; |
|
p++; |
|
count--; |
|
while (count) |
|
{ |
|
count--; |
|
l2 = *(unsigned short *)p; |
|
p += 2; |
|
outw(le16_to_cpu(l | l2 >> 8), port); |
|
l = l2 << 8; |
|
} |
|
l2 = *(unsigned char *)p; |
|
outw (le16_to_cpu(l | l2>>8), port); |
|
break; |
|
|
|
} |
|
} |
|
|
|
|
|
/* |
|
* Like insl but in the opposite direction. This is used by the IDE |
|
* driver to write disk sectors. Works with any alignment in SRC. |
|
* Performance is important, but the interfaces seems to be slow: |
|
* just using the inlined version of the outl() breaks things. |
|
*/ |
|
void outsl (unsigned long port, const void *src, unsigned long count) |
|
{ |
|
unsigned int l = 0, l2; |
|
const unsigned char *p; |
|
|
|
p = (const unsigned char *)src; |
|
|
|
if (!count) |
|
return; |
|
|
|
switch (((unsigned long)p) & 0x3) |
|
{ |
|
case 0x00: /* Buffer 32-bit aligned */ |
|
while (count--) |
|
{ |
|
outl(le32_to_cpu(*(unsigned int *)p), port); |
|
p += 4; |
|
} |
|
break; |
|
|
|
case 0x02: /* Buffer 16-bit aligned */ |
|
--count; |
|
|
|
l = *(unsigned short *)p; |
|
p += 2; |
|
|
|
while (count--) |
|
{ |
|
l2 = *(unsigned int *)p; |
|
p += 4; |
|
outl (le32_to_cpu(l << 16 | l2 >> 16), port); |
|
l = l2; |
|
} |
|
l2 = *(unsigned short *)p; |
|
outl (le32_to_cpu(l << 16 | l2), port); |
|
break; |
|
case 0x01: /* Buffer 8-bit aligned */ |
|
--count; |
|
|
|
l = *p << 24; |
|
p++; |
|
l |= *(unsigned short *)p << 8; |
|
p += 2; |
|
|
|
while (count--) |
|
{ |
|
l2 = *(unsigned int *)p; |
|
p += 4; |
|
outl (le32_to_cpu(l | l2 >> 24), port); |
|
l = l2 << 8; |
|
} |
|
l2 = *p; |
|
outl (le32_to_cpu(l | l2), port); |
|
break; |
|
case 0x03: /* Buffer 8-bit aligned */ |
|
--count; |
|
|
|
l = *p << 24; |
|
p++; |
|
|
|
while (count--) |
|
{ |
|
l2 = *(unsigned int *)p; |
|
p += 4; |
|
outl (le32_to_cpu(l | l2 >> 8), port); |
|
l = l2 << 24; |
|
} |
|
l2 = *(unsigned short *)p << 16; |
|
p += 2; |
|
l2 |= *p; |
|
outl (le32_to_cpu(l | l2), port); |
|
break; |
|
} |
|
} |
|
|
|
EXPORT_SYMBOL(insb); |
|
EXPORT_SYMBOL(insw); |
|
EXPORT_SYMBOL(insl); |
|
EXPORT_SYMBOL(outsb); |
|
EXPORT_SYMBOL(outsw); |
|
EXPORT_SYMBOL(outsl);
|
|
|