208 lines
4.5 KiB
C
208 lines
4.5 KiB
C
/*
|
|
* Copyright (C) 2000 David J. Mckay (david.mckay@st.com)
|
|
*
|
|
* May be copied or modified under the terms of the GNU General Public
|
|
* License. See linux/COPYING for more information.
|
|
*
|
|
* This file contains the I/O routines for use on the overdrive board
|
|
*
|
|
*/
|
|
|
|
#include <linux/config.h>
|
|
#include <linux/types.h>
|
|
#include <linux/delay.h>
|
|
#include <asm/system.h>
|
|
#include <asm/processor.h>
|
|
#include <asm/io.h>
|
|
#ifdef CONFIG_SH_CAYMAN
|
|
#include <asm/cayman.h>
|
|
#endif
|
|
|
|
/*
|
|
* readX/writeX() are used to access memory mapped devices. On some
|
|
* architectures the memory mapped IO stuff needs to be accessed
|
|
* differently. On the SuperH architecture, we just read/write the
|
|
* memory location directly.
|
|
*/
|
|
|
|
#define dprintk(x...)
|
|
|
|
static int io_addr(int x) {
|
|
if (x < 0x400) {
|
|
#ifdef CONFIG_SH_CAYMAN
|
|
return (x << 2) | smsc_superio_virt;
|
|
#else
|
|
panic ("Illegal access to I/O port 0x%04x\n", x);
|
|
return 0;
|
|
#endif
|
|
} else {
|
|
#ifdef CONFIG_PCI
|
|
return (x + pciio_virt);
|
|
#else
|
|
panic ("Illegal access to I/O port 0x%04x\n", x);
|
|
return 0;
|
|
#endif
|
|
}
|
|
}
|
|
|
|
unsigned long inb(unsigned long port)
|
|
{
|
|
unsigned long r;
|
|
|
|
r = ctrl_inb(io_addr(port));
|
|
dprintk("inb(0x%x)=0x%x (0x%x)\n", port, r, io_addr(port));
|
|
return r;
|
|
}
|
|
|
|
unsigned long inw(unsigned long port)
|
|
{
|
|
unsigned long r;
|
|
|
|
r = ctrl_inw(io_addr(port));
|
|
dprintk("inw(0x%x)=0x%x (0x%x)\n", port, r, io_addr(port));
|
|
return r;
|
|
}
|
|
|
|
unsigned long inl(unsigned long port)
|
|
{
|
|
unsigned long r;
|
|
|
|
r = ctrl_inl(io_addr(port));
|
|
dprintk("inl(0x%x)=0x%x (0x%x)\n", port, r, io_addr(port));
|
|
return r;
|
|
}
|
|
|
|
void outb(unsigned long value, unsigned long port)
|
|
{
|
|
dprintk("outb(0x%x,0x%x) (0x%x)\n", value, port, io_addr(port));
|
|
ctrl_outb(value, io_addr(port));
|
|
}
|
|
|
|
void outw(unsigned long value, unsigned long port)
|
|
{
|
|
dprintk("outw(0x%x,0x%x) (0x%x)\n", value, port, io_addr(port));
|
|
ctrl_outw(value, io_addr(port));
|
|
}
|
|
|
|
void outl(unsigned long value, unsigned long port)
|
|
{
|
|
dprintk("outw(0x%x,0x%x) (0x%x)\n", value, port, io_addr(port));
|
|
ctrl_outl(value, io_addr(port));
|
|
}
|
|
|
|
/* This is horrible at the moment - needs more work to do something sensible */
|
|
#define IO_DELAY()
|
|
|
|
#define OUT_DELAY(x,type) \
|
|
void out##x##_p(unsigned type value,unsigned long port){out##x(value,port);IO_DELAY();}
|
|
|
|
#define IN_DELAY(x,type) \
|
|
unsigned type in##x##_p(unsigned long port) {unsigned type tmp=in##x(port);IO_DELAY();return tmp;}
|
|
|
|
#if 1
|
|
OUT_DELAY(b, long) OUT_DELAY(w, long) OUT_DELAY(l, long)
|
|
IN_DELAY(b, long) IN_DELAY(w, long) IN_DELAY(l, long)
|
|
#endif
|
|
/* Now for the string version of these functions */
|
|
void outsb(unsigned long port, const void *addr, unsigned long count)
|
|
{
|
|
int i;
|
|
unsigned char *p = (unsigned char *) addr;
|
|
|
|
for (i = 0; i < count; i++, p++) {
|
|
outb(*p, port);
|
|
}
|
|
}
|
|
|
|
void insb(unsigned long port, void *addr, unsigned long count)
|
|
{
|
|
int i;
|
|
unsigned char *p = (unsigned char *) addr;
|
|
|
|
for (i = 0; i < count; i++, p++) {
|
|
*p = inb(port);
|
|
}
|
|
}
|
|
|
|
/* For the 16 and 32 bit string functions, we have to worry about alignment.
|
|
* The SH does not do unaligned accesses, so we have to read as bytes and
|
|
* then write as a word or dword.
|
|
* This can be optimised a lot more, especially in the case where the data
|
|
* is aligned
|
|
*/
|
|
|
|
void outsw(unsigned long port, const void *addr, unsigned long count)
|
|
{
|
|
int i;
|
|
unsigned short tmp;
|
|
unsigned char *p = (unsigned char *) addr;
|
|
|
|
for (i = 0; i < count; i++, p += 2) {
|
|
tmp = (*p) | ((*(p + 1)) << 8);
|
|
outw(tmp, port);
|
|
}
|
|
}
|
|
|
|
void insw(unsigned long port, void *addr, unsigned long count)
|
|
{
|
|
int i;
|
|
unsigned short tmp;
|
|
unsigned char *p = (unsigned char *) addr;
|
|
|
|
for (i = 0; i < count; i++, p += 2) {
|
|
tmp = inw(port);
|
|
p[0] = tmp & 0xff;
|
|
p[1] = (tmp >> 8) & 0xff;
|
|
}
|
|
}
|
|
|
|
void outsl(unsigned long port, const void *addr, unsigned long count)
|
|
{
|
|
int i;
|
|
unsigned tmp;
|
|
unsigned char *p = (unsigned char *) addr;
|
|
|
|
for (i = 0; i < count; i++, p += 4) {
|
|
tmp = (*p) | ((*(p + 1)) << 8) | ((*(p + 2)) << 16) |
|
|
((*(p + 3)) << 24);
|
|
outl(tmp, port);
|
|
}
|
|
}
|
|
|
|
void insl(unsigned long port, void *addr, unsigned long count)
|
|
{
|
|
int i;
|
|
unsigned tmp;
|
|
unsigned char *p = (unsigned char *) addr;
|
|
|
|
for (i = 0; i < count; i++, p += 4) {
|
|
tmp = inl(port);
|
|
p[0] = tmp & 0xff;
|
|
p[1] = (tmp >> 8) & 0xff;
|
|
p[2] = (tmp >> 16) & 0xff;
|
|
p[3] = (tmp >> 24) & 0xff;
|
|
|
|
}
|
|
}
|
|
|
|
void memcpy_toio(unsigned long to, const void *from, long count)
|
|
{
|
|
unsigned char *p = (unsigned char *) from;
|
|
|
|
while (count) {
|
|
count--;
|
|
writeb(*p++, to++);
|
|
}
|
|
}
|
|
|
|
void memcpy_fromio(void *to, unsigned long from, long count)
|
|
{
|
|
int i;
|
|
unsigned char *p = (unsigned char *) to;
|
|
|
|
for (i = 0; i < count; i++) {
|
|
p[i] = readb(from);
|
|
from++;
|
|
}
|
|
}
|