OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [arch/] [sh/] [kernel/] [io_snapgear.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 1275 phoenix 
/*
2 
 * linux/arch/sh/kernel/io_7751se.c
3 
 *
4 
 * Copyright (C) 2002  David McCullough <davidm@snapgear.com>
5 
 * Copyright (C) 2001  Ian da Silva, Jeremy Siegel
6 
 * Based largely on io_se.c.
7 
 *
8 
 * I/O routine for Hitachi 7751 SolutionEngine.
9 
 *
10 
 * Initial version only to support LAN access; some
11 
 * placeholder code from io_se.c left in with the
12 
 * expectation of later SuperIO and PCMCIA access.
13 
 */
14 
 
15 
#include <linux/kernel.h>
16 
#include <linux/types.h>
17 
#include <linux/pci.h>
18 
#include <asm/io.h>
19 
#include <asm/addrspace.h>
20 
 
21 
#include <asm/pci.h>
22 
#include <asm/pci-sh7751.h>
23 
 
24 
#ifdef CONFIG_SH_SECUREEDGE5410
25 
unsigned short secureedge5410_ioport;
26 
#endif
27 
 
28 
/*
29 
 * The SnapGear uses the built-in PCI controller (PCIC)
30 
 * of the 7751 processor
31 
 */
32 
 
33 
#define PCIIOBR         (volatile long *)PCI_REG(SH7751_PCIIOBR)
34 
#define PCIMBR          (volatile long *)PCI_REG(SH7751_PCIMBR)
35 
#define PCI_IO_AREA     SH7751_PCI_IO_BASE
36 
#define PCI_MEM_AREA    SH7751_PCI_CONFIG_BASE
37 
 
38 
 
39 
#define PCI_IOMAP(adr)  (PCI_IO_AREA + (adr & ~SH7751_PCIIOBR_MASK))
40 
 
41 
 
42 
#define maybebadio(name,port) \
43 
  printk("bad PC-like io %s for port 0x%lx at 0x%08x\n", \
44 
         #name, (port), (__u32) __builtin_return_address(0))
45 
 
46 
 
47 
static inline void delay(void)
48 
{
49 
        ctrl_inw(0xa0000000);
50 
}
51 
 
52 
 
53 
static inline volatile __u16 *
54 
port2adr(unsigned int port)
55 
{
56 
#if 0
57 
        if (port >= 0x2000)
58 
                return (volatile __u16 *) (PA_MRSHPC + (port - 0x2000));
59 
#endif
60 
        maybebadio(name,port);
61 
        return (volatile __u16*)port;
62 
}
63 
 
64 
 
65 
/* In case someone configures the kernel w/o PCI support: in that */
66 
/* scenario, don't ever bother to check for PCI-window addresses */
67 
 
68 
/* NOTE: WINDOW CHECK MAY BE A BIT OFF, HIGH PCIBIOS_MIN_IO WRAPS? */
69 
#if defined(CONFIG_PCI)
70 
#define CHECK_SH7751_PCIIO(port) \
71 
  ((port >= PCIBIOS_MIN_IO) && (port < (PCIBIOS_MIN_IO + SH7751_PCI_IO_SIZE)))
72 
#else
73 
#define CHECK_SH7751_PCIIO(port) (0)
74 
#endif
75 
 
76 
/*
77 
 * General outline: remap really low stuff [eventually] to SuperIO,
78 
 * stuff in PCI IO space (at or above window at pci.h:PCIBIOS_MIN_IO)
79 
 * is mapped through the PCI IO window.  Stuff with high bits (PXSEG)
80 
 * should be way beyond the window, and is used  w/o translation for
81 
 * compatibility.
82 
 */
83 
 
84 
unsigned char snapgear_inb(unsigned long port)
85 
{
86 
        if (PXSEG(port))
87 
                return *(volatile unsigned char *)port;
88 
        else if (CHECK_SH7751_PCIIO(port))
89 
                return *(volatile unsigned char *)PCI_IOMAP(port);
90 
        else
91 
                return (*port2adr(port))&0xff;
92 
}
93 
 
94 
 
95 
unsigned char snapgear_inb_p(unsigned long port)
96 
{
97 
        unsigned char v;
98 
 
99 
        if (PXSEG(port))
100 
                v = *(volatile unsigned char *)port;
101 
        else if (CHECK_SH7751_PCIIO(port))
102 
                v = *(volatile unsigned char *)PCI_IOMAP(port);
103 
        else
104 
                v = (*port2adr(port))&0xff;
105 
        delay();
106 
        return v;
107 
}
108 
 
109 
 
110 
unsigned short snapgear_inw(unsigned long port)
111 
{
112 
        if (PXSEG(port))
113 
                return *(volatile unsigned short *)port;
114 
        else if (CHECK_SH7751_PCIIO(port))
115 
                return *(volatile unsigned short *)PCI_IOMAP(port);
116 
        else if (port >= 0x2000)
117 
                return *port2adr(port);
118 
        else
119 
                maybebadio(inw, port);
120 
        return 0;
121 
}
122 
 
123 
 
124 
unsigned int snapgear_inl(unsigned long port)
125 
{
126 
        if (PXSEG(port))
127 
                return *(volatile unsigned long *)port;
128 
        else if (CHECK_SH7751_PCIIO(port))
129 
                return *(volatile unsigned int *)PCI_IOMAP(port);
130 
        else if (port >= 0x2000)
131 
                return *port2adr(port);
132 
        else
133 
                maybebadio(inl, port);
134 
        return 0;
135 
}
136 
 
137 
 
138 
void snapgear_outb(unsigned char value, unsigned long port)
139 
{
140 
 
141 
        if (PXSEG(port))
142 
                *(volatile unsigned char *)port = value;
143 
        else if (CHECK_SH7751_PCIIO(port))
144 
                *((unsigned char*)PCI_IOMAP(port)) = value;
145 
        else
146 
                *(port2adr(port)) = value;
147 
}
148 
 
149 
 
150 
void snapgear_outb_p(unsigned char value, unsigned long port)
151 
{
152 
        if (PXSEG(port))
153 
                *(volatile unsigned char *)port = value;
154 
        else if (CHECK_SH7751_PCIIO(port))
155 
                *((unsigned char*)PCI_IOMAP(port)) = value;
156 
        else
157 
                *(port2adr(port)) = value;
158 
        delay();
159 
}
160 
 
161 
 
162 
void snapgear_outw(unsigned short value, unsigned long port)
163 
{
164 
        if (PXSEG(port))
165 
                *(volatile unsigned short *)port = value;
166 
        else if (CHECK_SH7751_PCIIO(port))
167 
                *((unsigned short *)PCI_IOMAP(port)) = value;
168 
        else if (port >= 0x2000)
169 
                *port2adr(port) = value;
170 
        else
171 
                maybebadio(outw, port);
172 
}
173 
 
174 
 
175 
void snapgear_outl(unsigned int value, unsigned long port)
176 
{
177 
        if (PXSEG(port))
178 
                *(volatile unsigned long *)port = value;
179 
        else if (CHECK_SH7751_PCIIO(port))
180 
                *((unsigned long*)PCI_IOMAP(port)) = value;
181 
        else
182 
                maybebadio(outl, port);
183 
}
184 
 
185 
 
186 
void snapgear_insb(unsigned long port, void *addr, unsigned long count)
187 
{
188 
        unsigned char *p = addr;
189 
        while (count--) *p++ = snapgear_inb(port);
190 
}
191 
 
192 
 
193 
void snapgear_insw(unsigned long port, void *addr, unsigned long count)
194 
{
195 
        unsigned short *p = addr;
196 
        while (count--) *p++ = snapgear_inw(port);
197 
}
198 
 
199 
 
200 
void snapgear_insl(unsigned long port, void *addr, unsigned long count)
201 
{
202 
        maybebadio(insl, port);
203 
}
204 
 
205 
 
206 
void snapgear_outsb(unsigned long port, const void *addr, unsigned long count)
207 
{
208 
        unsigned char *p = (unsigned char*)addr;
209 
        while (count--) snapgear_outb(*p++, port);
210 
}
211 
 
212 
 
213 
void snapgear_outsw(unsigned long port, const void *addr, unsigned long count)
214 
{
215 
        unsigned short *p = (unsigned short*)addr;
216 
        while (count--) snapgear_outw(*p++, port);
217 
}
218 
 
219 
 
220 
void snapgear_outsl(unsigned long port, const void *addr, unsigned long count)
221 
{
222 
        maybebadio(outsw, port);
223 
}
224 
 
225 
 
226 
/* For read/write calls, just copy generic (pass-thru); PCIMBR is  */
227 
/* already set up.  For a larger memory space, these would need to */
228 
/* reset PCIMBR as needed on a per-call basis...                   */
229 
 
230 
unsigned char snapgear_readb(unsigned long addr)
231 
{
232 
        return (* ((volatile unsigned char *) addr));
233 
}
234 
 
235 
 
236 
unsigned short snapgear_readw(unsigned long addr)
237 
{
238 
        return (* ((volatile unsigned short *) addr));
239 
}
240 
 
241 
 
242 
unsigned int snapgear_readl(unsigned long addr)
243 
{
244 
        return (* ((volatile unsigned long *) addr));
245 
}
246 
 
247 
 
248 
void snapgear_writeb(unsigned char b, unsigned long addr)
249 
{
250 
        *(volatile unsigned char*)addr = b;
251 
}
252 
 
253 
 
254 
void snapgear_writew(unsigned short b, unsigned long addr)
255 
{
256 
        *(volatile unsigned short*)addr = b;
257 
}
258 
 
259 
 
260 
void snapgear_writel(unsigned int b, unsigned long addr)
261 
{
262 
        *(volatile unsigned long*)addr = b;
263 
}
264 
 
265 
 
266 
/* Map ISA bus address to the real address. Only for PCMCIA.  */
267 
 
268 
 
269 
/* ISA page descriptor.  */
270 
static __u32 sh_isa_memmap[256];
271 
 
272 
 
273 
static int
274 
sh_isa_mmap(__u32 start, __u32 length, __u32 offset)
275 
{
276 
        int idx;
277 
 
278 
        if (start >= 0x100000 || (start & 0xfff) || (length != 0x1000))
279 
                return -1;
280 
 
281 
        idx = start >> 12;
282 
        sh_isa_memmap[idx] = 0xb8000000 + (offset &~ 0xfff);
283 
#if 0
284 
        printk("sh_isa_mmap: start %x len %x offset %x (idx %x paddr %x)\n",
285 
               start, length, offset, idx, sh_isa_memmap[idx]);
286 
#endif
287 
        return 0;
288 
}
289 
 
290 
 
291 
unsigned long
292 
snapgear_isa_port2addr(unsigned long offset)
293 
{
294 
        int idx;
295 
 
296 
        idx = (offset >> 12) & 0xff;
297 
        offset &= 0xfff;
298 
        return sh_isa_memmap[idx] + offset;
299 
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.