1*00f892fcSMacpaul Lin /* 2*00f892fcSMacpaul Lin * linux/include/asm-nds/io.h 3*00f892fcSMacpaul Lin * 4*00f892fcSMacpaul Lin * Copyright (C) 1996-2000 Russell King 5*00f892fcSMacpaul Lin * 6*00f892fcSMacpaul Lin * Copyright (C) 2011 Andes Technology Corporation 7*00f892fcSMacpaul Lin * Shawn Lin, Andes Technology Corporation <nobuhiro@andestech.com> 8*00f892fcSMacpaul Lin * Macpaul Lin, Andes Technology Corporation <macpaul@andestech.com> 9*00f892fcSMacpaul Lin * 10*00f892fcSMacpaul Lin * This program is free software; you can redistribute it and/or modify 11*00f892fcSMacpaul Lin * it under the terms of the GNU General Public License version 2 as 12*00f892fcSMacpaul Lin * published by the Free Software Foundation. 13*00f892fcSMacpaul Lin * 14*00f892fcSMacpaul Lin * Modifications: 15*00f892fcSMacpaul Lin * 16-Sep-1996 RMK Inlined the inx/outx functions & optimised for both 16*00f892fcSMacpaul Lin * constant addresses and variable addresses. 17*00f892fcSMacpaul Lin * 04-Dec-1997 RMK Moved a lot of this stuff to the new architecture 18*00f892fcSMacpaul Lin * specific IO header files. 19*00f892fcSMacpaul Lin * 27-Mar-1999 PJB Second parameter of memcpy_toio is const.. 20*00f892fcSMacpaul Lin * 04-Apr-1999 PJB Added check_signature. 21*00f892fcSMacpaul Lin * 12-Dec-1999 RMK More cleanups 22*00f892fcSMacpaul Lin * 18-Jun-2000 RMK Removed virt_to_* and friends definitions 23*00f892fcSMacpaul Lin */ 24*00f892fcSMacpaul Lin #ifndef __ASM_NDS_IO_H 25*00f892fcSMacpaul Lin #define __ASM_NDS_IO_H 26*00f892fcSMacpaul Lin 27*00f892fcSMacpaul Lin /* 28*00f892fcSMacpaul Lin * CAUTION: 29*00f892fcSMacpaul Lin * - do not implement for NDS32 Arch yet. 30*00f892fcSMacpaul Lin * - cmd_pci.c, cmd_scsi.c, Lynxkdi.c, usb.c, usb_storage.c, etc... 31*00f892fcSMacpaul Lin * iinclude asm/io.h 32*00f892fcSMacpaul Lin */ 33*00f892fcSMacpaul Lin 34*00f892fcSMacpaul Lin #ifdef __KERNEL__ 35*00f892fcSMacpaul Lin 36*00f892fcSMacpaul Lin #include <linux/types.h> 37*00f892fcSMacpaul Lin #include <asm/byteorder.h> 38*00f892fcSMacpaul Lin 39*00f892fcSMacpaul Lin static inline void sync(void) 40*00f892fcSMacpaul Lin { 41*00f892fcSMacpaul Lin } 42*00f892fcSMacpaul Lin 43*00f892fcSMacpaul Lin /* 44*00f892fcSMacpaul Lin * Given a physical address and a length, return a virtual address 45*00f892fcSMacpaul Lin * that can be used to access the memory range with the caching 46*00f892fcSMacpaul Lin * properties specified by "flags". 47*00f892fcSMacpaul Lin */ 48*00f892fcSMacpaul Lin #define MAP_NOCACHE (0) 49*00f892fcSMacpaul Lin #define MAP_WRCOMBINE (0) 50*00f892fcSMacpaul Lin #define MAP_WRBACK (0) 51*00f892fcSMacpaul Lin #define MAP_WRTHROUGH (0) 52*00f892fcSMacpaul Lin 53*00f892fcSMacpaul Lin static inline void * 54*00f892fcSMacpaul Lin map_physmem(phys_addr_t paddr, unsigned long len, unsigned long flags) 55*00f892fcSMacpaul Lin { 56*00f892fcSMacpaul Lin return (void *)paddr; 57*00f892fcSMacpaul Lin } 58*00f892fcSMacpaul Lin 59*00f892fcSMacpaul Lin /* 60*00f892fcSMacpaul Lin * Take down a mapping set up by map_physmem(). 61*00f892fcSMacpaul Lin */ 62*00f892fcSMacpaul Lin static inline void unmap_physmem(void *vaddr, unsigned long flags) 63*00f892fcSMacpaul Lin { 64*00f892fcSMacpaul Lin 65*00f892fcSMacpaul Lin } 66*00f892fcSMacpaul Lin 67*00f892fcSMacpaul Lin static inline phys_addr_t virt_to_phys(void *vaddr) 68*00f892fcSMacpaul Lin { 69*00f892fcSMacpaul Lin return (phys_addr_t)(vaddr); 70*00f892fcSMacpaul Lin } 71*00f892fcSMacpaul Lin 72*00f892fcSMacpaul Lin /* 73*00f892fcSMacpaul Lin * Generic virtual read/write. Note that we don't support half-word 74*00f892fcSMacpaul Lin * read/writes. We define __arch_*[bl] here, and leave __arch_*w 75*00f892fcSMacpaul Lin * to the architecture specific code. 76*00f892fcSMacpaul Lin */ 77*00f892fcSMacpaul Lin #define __arch_getb(a) (*(unsigned char *)(a)) 78*00f892fcSMacpaul Lin #define __arch_getw(a) (*(unsigned short *)(a)) 79*00f892fcSMacpaul Lin #define __arch_getl(a) (*(unsigned int *)(a)) 80*00f892fcSMacpaul Lin 81*00f892fcSMacpaul Lin #define __arch_putb(v, a) (*(unsigned char *)(a) = (v)) 82*00f892fcSMacpaul Lin #define __arch_putw(v, a) (*(unsigned short *)(a) = (v)) 83*00f892fcSMacpaul Lin #define __arch_putl(v, a) (*(unsigned int *)(a) = (v)) 84*00f892fcSMacpaul Lin 85*00f892fcSMacpaul Lin extern void __raw_writesb(unsigned int addr, const void *data, int bytelen); 86*00f892fcSMacpaul Lin extern void __raw_writesw(unsigned int addr, const void *data, int wordlen); 87*00f892fcSMacpaul Lin extern void __raw_writesl(unsigned int addr, const void *data, int longlen); 88*00f892fcSMacpaul Lin 89*00f892fcSMacpaul Lin extern void __raw_readsb(unsigned int addr, void *data, int bytelen); 90*00f892fcSMacpaul Lin extern void __raw_readsw(unsigned int addr, void *data, int wordlen); 91*00f892fcSMacpaul Lin extern void __raw_readsl(unsigned int addr, void *data, int longlen); 92*00f892fcSMacpaul Lin 93*00f892fcSMacpaul Lin #define __raw_writeb(v, a) __arch_putb(v, a) 94*00f892fcSMacpaul Lin #define __raw_writew(v, a) __arch_putw(v, a) 95*00f892fcSMacpaul Lin #define __raw_writel(v, a) __arch_putl(v, a) 96*00f892fcSMacpaul Lin 97*00f892fcSMacpaul Lin #define __raw_readb(a) __arch_getb(a) 98*00f892fcSMacpaul Lin #define __raw_readw(a) __arch_getw(a) 99*00f892fcSMacpaul Lin #define __raw_readl(a) __arch_getl(a) 100*00f892fcSMacpaul Lin 101*00f892fcSMacpaul Lin #define writeb(v, a) __arch_putb(v, a) 102*00f892fcSMacpaul Lin #define writew(v, a) __arch_putw(v, a) 103*00f892fcSMacpaul Lin #define writel(v, a) __arch_putl(v, a) 104*00f892fcSMacpaul Lin 105*00f892fcSMacpaul Lin #define readb(a) __arch_getb(a) 106*00f892fcSMacpaul Lin #define readw(a) __arch_getw(a) 107*00f892fcSMacpaul Lin #define readl(a) __arch_getl(a) 108*00f892fcSMacpaul Lin 109*00f892fcSMacpaul Lin /* 110*00f892fcSMacpaul Lin * The compiler seems to be incapable of optimising constants 111*00f892fcSMacpaul Lin * properly. Spell it out to the compiler in some cases. 112*00f892fcSMacpaul Lin * These are only valid for small values of "off" (< 1<<12) 113*00f892fcSMacpaul Lin */ 114*00f892fcSMacpaul Lin #define __raw_base_writeb(val, base, off) __arch_base_putb(val, base, off) 115*00f892fcSMacpaul Lin #define __raw_base_writew(val, base, off) __arch_base_putw(val, base, off) 116*00f892fcSMacpaul Lin #define __raw_base_writel(val, base, off) __arch_base_putl(val, base, off) 117*00f892fcSMacpaul Lin 118*00f892fcSMacpaul Lin #define __raw_base_readb(base, off) __arch_base_getb(base, off) 119*00f892fcSMacpaul Lin #define __raw_base_readw(base, off) __arch_base_getw(base, off) 120*00f892fcSMacpaul Lin #define __raw_base_readl(base, off) __arch_base_getl(base, off) 121*00f892fcSMacpaul Lin 122*00f892fcSMacpaul Lin /* 123*00f892fcSMacpaul Lin * Now, pick up the machine-defined IO definitions 124*00f892fcSMacpaul Lin * #include <asm/arch/io.h> 125*00f892fcSMacpaul Lin */ 126*00f892fcSMacpaul Lin 127*00f892fcSMacpaul Lin /* 128*00f892fcSMacpaul Lin * IO port access primitives 129*00f892fcSMacpaul Lin * ------------------------- 130*00f892fcSMacpaul Lin * 131*00f892fcSMacpaul Lin * The NDS32 doesn't have special IO access instructions just like ARM; 132*00f892fcSMacpaul Lin * all IO is memory mapped. 133*00f892fcSMacpaul Lin * Note that these are defined to perform little endian accesses 134*00f892fcSMacpaul Lin * only. Their primary purpose is to access PCI and ISA peripherals. 135*00f892fcSMacpaul Lin * 136*00f892fcSMacpaul Lin * Note that for a big endian machine, this implies that the following 137*00f892fcSMacpaul Lin * big endian mode connectivity is in place, as described by numerious 138*00f892fcSMacpaul Lin * ARM documents: 139*00f892fcSMacpaul Lin * 140*00f892fcSMacpaul Lin * PCI: D0-D7 D8-D15 D16-D23 D24-D31 141*00f892fcSMacpaul Lin * ARM: D24-D31 D16-D23 D8-D15 D0-D7 142*00f892fcSMacpaul Lin * 143*00f892fcSMacpaul Lin * The machine specific io.h include defines __io to translate an "IO" 144*00f892fcSMacpaul Lin * address to a memory address. 145*00f892fcSMacpaul Lin * 146*00f892fcSMacpaul Lin * Note that we prevent GCC re-ordering or caching values in expressions 147*00f892fcSMacpaul Lin * by introducing sequence points into the in*() definitions. Note that 148*00f892fcSMacpaul Lin * __raw_* do not guarantee this behaviour. 149*00f892fcSMacpaul Lin * 150*00f892fcSMacpaul Lin * The {in,out}[bwl] macros are for emulating x86-style PCI/ISA IO space. 151*00f892fcSMacpaul Lin */ 152*00f892fcSMacpaul Lin #ifdef __io 153*00f892fcSMacpaul Lin #define outb(v, p) __raw_writeb(v, __io(p)) 154*00f892fcSMacpaul Lin #define outw(v, p) __raw_writew(cpu_to_le16(v), __io(p)) 155*00f892fcSMacpaul Lin #define outl(v, p) __raw_writel(cpu_to_le32(v), __io(p)) 156*00f892fcSMacpaul Lin 157*00f892fcSMacpaul Lin #define inb(p) ({ unsigned int __v = __raw_readb(__io(p)); __v; }) 158*00f892fcSMacpaul Lin #define inw(p) ({ unsigned int __v = le16_to_cpu(__raw_readw(__io(p))); __v; }) 159*00f892fcSMacpaul Lin #define inl(p) ({ unsigned int __v = le32_to_cpu(__raw_readl(__io(p))); __v; }) 160*00f892fcSMacpaul Lin 161*00f892fcSMacpaul Lin #define outsb(p, d, l) writesb(__io(p), d, l) 162*00f892fcSMacpaul Lin #define outsw(p, d, l) writesw(__io(p), d, l) 163*00f892fcSMacpaul Lin #define outsl(p, d, l) writesl(__io(p), d, l) 164*00f892fcSMacpaul Lin 165*00f892fcSMacpaul Lin #define insb(p, d, l) readsb(__io(p), d, l) 166*00f892fcSMacpaul Lin #define insw(p, d, l) readsw(__io(p), d, l) 167*00f892fcSMacpaul Lin #define insl(p, d, l) readsl(__io(p), d, l) 168*00f892fcSMacpaul Lin 169*00f892fcSMacpaul Lin static inline void readsb(unsigned int *addr, void * data, int bytelen) 170*00f892fcSMacpaul Lin { 171*00f892fcSMacpaul Lin unsigned char *ptr = (unsigned char *)addr; 172*00f892fcSMacpaul Lin unsigned char *ptr2 = (unsigned char *)data; 173*00f892fcSMacpaul Lin while (bytelen) { 174*00f892fcSMacpaul Lin *ptr2 = *ptr; 175*00f892fcSMacpaul Lin ptr2++; 176*00f892fcSMacpaul Lin bytelen--; 177*00f892fcSMacpaul Lin } 178*00f892fcSMacpaul Lin } 179*00f892fcSMacpaul Lin 180*00f892fcSMacpaul Lin static inline void readsw(unsigned int *addr, void * data, int wordlen) 181*00f892fcSMacpaul Lin { 182*00f892fcSMacpaul Lin unsigned short *ptr = (unsigned short *)addr; 183*00f892fcSMacpaul Lin unsigned short *ptr2 = (unsigned short *)data; 184*00f892fcSMacpaul Lin while (wordlen) { 185*00f892fcSMacpaul Lin *ptr2 = *ptr; 186*00f892fcSMacpaul Lin ptr2++; 187*00f892fcSMacpaul Lin wordlen--; 188*00f892fcSMacpaul Lin } 189*00f892fcSMacpaul Lin } 190*00f892fcSMacpaul Lin 191*00f892fcSMacpaul Lin static inline void readsl(unsigned int *addr, void * data, int longlen) 192*00f892fcSMacpaul Lin { 193*00f892fcSMacpaul Lin unsigned int *ptr = (unsigned int *)addr; 194*00f892fcSMacpaul Lin unsigned int *ptr2 = (unsigned int *)data; 195*00f892fcSMacpaul Lin while (longlen) { 196*00f892fcSMacpaul Lin *ptr2 = *ptr; 197*00f892fcSMacpaul Lin ptr2++; 198*00f892fcSMacpaul Lin longlen--; 199*00f892fcSMacpaul Lin } 200*00f892fcSMacpaul Lin } 201*00f892fcSMacpaul Lin static inline void writesb(unsigned int *addr, const void * data, int bytelen) 202*00f892fcSMacpaul Lin { 203*00f892fcSMacpaul Lin unsigned char *ptr = (unsigned char *)addr; 204*00f892fcSMacpaul Lin unsigned char *ptr2 = (unsigned char *)data; 205*00f892fcSMacpaul Lin while (bytelen) { 206*00f892fcSMacpaul Lin *ptr = *ptr2; 207*00f892fcSMacpaul Lin ptr2++; 208*00f892fcSMacpaul Lin bytelen--; 209*00f892fcSMacpaul Lin } 210*00f892fcSMacpaul Lin } 211*00f892fcSMacpaul Lin static inline void writesw(unsigned int *addr, const void * data, int wordlen) 212*00f892fcSMacpaul Lin { 213*00f892fcSMacpaul Lin unsigned short *ptr = (unsigned short *)addr; 214*00f892fcSMacpaul Lin unsigned short *ptr2 = (unsigned short *)data; 215*00f892fcSMacpaul Lin while (wordlen) { 216*00f892fcSMacpaul Lin *ptr = *ptr2; 217*00f892fcSMacpaul Lin ptr2++; 218*00f892fcSMacpaul Lin wordlen--; 219*00f892fcSMacpaul Lin } 220*00f892fcSMacpaul Lin } 221*00f892fcSMacpaul Lin static inline void writesl(unsigned int *addr, const void * data, int longlen) 222*00f892fcSMacpaul Lin { 223*00f892fcSMacpaul Lin unsigned int *ptr = (unsigned int *)addr; 224*00f892fcSMacpaul Lin unsigned int *ptr2 = (unsigned int *)data; 225*00f892fcSMacpaul Lin while (longlen) { 226*00f892fcSMacpaul Lin *ptr = *ptr2; 227*00f892fcSMacpaul Lin ptr2++; 228*00f892fcSMacpaul Lin longlen--; 229*00f892fcSMacpaul Lin } 230*00f892fcSMacpaul Lin } 231*00f892fcSMacpaul Lin #endif 232*00f892fcSMacpaul Lin 233*00f892fcSMacpaul Lin #define outb_p(val, port) outb((val), (port)) 234*00f892fcSMacpaul Lin #define outw_p(val, port) outw((val), (port)) 235*00f892fcSMacpaul Lin #define outl_p(val, port) outl((val), (port)) 236*00f892fcSMacpaul Lin #define inb_p(port) inb((port)) 237*00f892fcSMacpaul Lin #define inw_p(port) inw((port)) 238*00f892fcSMacpaul Lin #define inl_p(port) inl((port)) 239*00f892fcSMacpaul Lin 240*00f892fcSMacpaul Lin #define outsb_p(port, from, len) outsb(port, from, len) 241*00f892fcSMacpaul Lin #define outsw_p(port, from, len) outsw(port, from, len) 242*00f892fcSMacpaul Lin #define outsl_p(port, from, len) outsl(port, from, len) 243*00f892fcSMacpaul Lin #define insb_p(port, to, len) insb(port, to, len) 244*00f892fcSMacpaul Lin #define insw_p(port, to, len) insw(port, to, len) 245*00f892fcSMacpaul Lin #define insl_p(port, to, len) insl(port, to, len) 246*00f892fcSMacpaul Lin 247*00f892fcSMacpaul Lin /* 248*00f892fcSMacpaul Lin * ioremap and friends. 249*00f892fcSMacpaul Lin * 250*00f892fcSMacpaul Lin * ioremap takes a PCI memory address, as specified in 251*00f892fcSMacpaul Lin * linux/Documentation/IO-mapping.txt. If you want a 252*00f892fcSMacpaul Lin * physical address, use __ioremap instead. 253*00f892fcSMacpaul Lin */ 254*00f892fcSMacpaul Lin extern void *__ioremap(unsigned long offset, size_t size, unsigned long flags); 255*00f892fcSMacpaul Lin extern void __iounmap(void *addr); 256*00f892fcSMacpaul Lin 257*00f892fcSMacpaul Lin /* 258*00f892fcSMacpaul Lin * Generic ioremap support. 259*00f892fcSMacpaul Lin * 260*00f892fcSMacpaul Lin * Define: 261*00f892fcSMacpaul Lin * iomem_valid_addr(off,size) 262*00f892fcSMacpaul Lin * iomem_to_phys(off) 263*00f892fcSMacpaul Lin */ 264*00f892fcSMacpaul Lin #ifdef iomem_valid_addr 265*00f892fcSMacpaul Lin #define __arch_ioremap(off, sz, nocache) \ 266*00f892fcSMacpaul Lin ({ \ 267*00f892fcSMacpaul Lin unsigned long _off = (off), _size = (sz); \ 268*00f892fcSMacpaul Lin void *_ret = (void *)0; \ 269*00f892fcSMacpaul Lin if (iomem_valid_addr(_off, _size)) \ 270*00f892fcSMacpaul Lin _ret = __ioremap(iomem_to_phys(_off), _size, 0); \ 271*00f892fcSMacpaul Lin _ret; \ 272*00f892fcSMacpaul Lin }) 273*00f892fcSMacpaul Lin 274*00f892fcSMacpaul Lin #define __arch_iounmap __iounmap 275*00f892fcSMacpaul Lin #endif 276*00f892fcSMacpaul Lin 277*00f892fcSMacpaul Lin #define ioremap(off, sz) __arch_ioremap((off), (sz), 0) 278*00f892fcSMacpaul Lin #define ioremap_nocache(off, sz) __arch_ioremap((off), (sz), 1) 279*00f892fcSMacpaul Lin #define iounmap(_addr) __arch_iounmap(_addr) 280*00f892fcSMacpaul Lin 281*00f892fcSMacpaul Lin /* 282*00f892fcSMacpaul Lin * DMA-consistent mapping functions. These allocate/free a region of 283*00f892fcSMacpaul Lin * uncached, unwrite-buffered mapped memory space for use with DMA 284*00f892fcSMacpaul Lin * devices. This is the "generic" version. The PCI specific version 285*00f892fcSMacpaul Lin * is in pci.h 286*00f892fcSMacpaul Lin */ 287*00f892fcSMacpaul Lin extern void *consistent_alloc(int gfp, size_t size, dma_addr_t *handle); 288*00f892fcSMacpaul Lin extern void consistent_free(void *vaddr, size_t size, dma_addr_t handle); 289*00f892fcSMacpaul Lin extern void consistent_sync(void *vaddr, size_t size, int rw); 290*00f892fcSMacpaul Lin 291*00f892fcSMacpaul Lin /* 292*00f892fcSMacpaul Lin * String version of IO memory access ops: 293*00f892fcSMacpaul Lin */ 294*00f892fcSMacpaul Lin extern void _memcpy_fromio(void *, unsigned long, size_t); 295*00f892fcSMacpaul Lin extern void _memcpy_toio(unsigned long, const void *, size_t); 296*00f892fcSMacpaul Lin extern void _memset_io(unsigned long, int, size_t); 297*00f892fcSMacpaul Lin 298*00f892fcSMacpaul Lin extern void __readwrite_bug(const char *fn); 299*00f892fcSMacpaul Lin 300*00f892fcSMacpaul Lin /* 301*00f892fcSMacpaul Lin * If this architecture has PCI memory IO, then define the read/write 302*00f892fcSMacpaul Lin * macros. These should only be used with the cookie passed from 303*00f892fcSMacpaul Lin * ioremap. 304*00f892fcSMacpaul Lin */ 305*00f892fcSMacpaul Lin #ifdef __mem_pci 306*00f892fcSMacpaul Lin 307*00f892fcSMacpaul Lin #define readb(c) ({ unsigned int __v = \ 308*00f892fcSMacpaul Lin __raw_readb(__mem_pci(c)); __v; }) 309*00f892fcSMacpaul Lin #define readw(c) ({ unsigned int __v = \ 310*00f892fcSMacpaul Lin le16_to_cpu(__raw_readw(__mem_pci(c))); __v; }) 311*00f892fcSMacpaul Lin #define readl(c) ({ unsigned int __v = \ 312*00f892fcSMacpaul Lin le32_to_cpu(__raw_readl(__mem_pci(c))); __v; }) 313*00f892fcSMacpaul Lin 314*00f892fcSMacpaul Lin #define writeb(v, c) __raw_writeb(v, __mem_pci(c)) 315*00f892fcSMacpaul Lin #define writew(v, c) __raw_writew(cpu_to_le16(v), __mem_pci(c)) 316*00f892fcSMacpaul Lin #define writel(v, c) __raw_writel(cpu_to_le32(v), __mem_pci(c)) 317*00f892fcSMacpaul Lin 318*00f892fcSMacpaul Lin #define memset_io(c, v, l) _memset_io(__mem_pci(c), (v), (l)) 319*00f892fcSMacpaul Lin #define memcpy_fromio(a, c, l) _memcpy_fromio((a), __mem_pci(c), (l)) 320*00f892fcSMacpaul Lin #define memcpy_toio(c, a, l) _memcpy_toio(__mem_pci(c), (a), (l)) 321*00f892fcSMacpaul Lin 322*00f892fcSMacpaul Lin #define eth_io_copy_and_sum(s, c, l, b) \ 323*00f892fcSMacpaul Lin eth_copy_and_sum((s), __mem_pci(c), (l), (b)) 324*00f892fcSMacpaul Lin 325*00f892fcSMacpaul Lin static inline int 326*00f892fcSMacpaul Lin check_signature(unsigned long io_addr, const unsigned char *signature, 327*00f892fcSMacpaul Lin int length) 328*00f892fcSMacpaul Lin { 329*00f892fcSMacpaul Lin int retval = 0; 330*00f892fcSMacpaul Lin do { 331*00f892fcSMacpaul Lin if (readb(io_addr) != *signature) 332*00f892fcSMacpaul Lin goto out; 333*00f892fcSMacpaul Lin io_addr++; 334*00f892fcSMacpaul Lin signature++; 335*00f892fcSMacpaul Lin length--; 336*00f892fcSMacpaul Lin } while (length); 337*00f892fcSMacpaul Lin retval = 1; 338*00f892fcSMacpaul Lin out: 339*00f892fcSMacpaul Lin return retval; 340*00f892fcSMacpaul Lin } 341*00f892fcSMacpaul Lin 342*00f892fcSMacpaul Lin #elif !defined(readb) 343*00f892fcSMacpaul Lin 344*00f892fcSMacpaul Lin #define readb(addr) (__readwrite_bug("readb"), 0) 345*00f892fcSMacpaul Lin #define readw(addr) (__readwrite_bug("readw"), 0) 346*00f892fcSMacpaul Lin #define readl(addr) (__readwrite_bug("readl"), 0) 347*00f892fcSMacpaul Lin #define writeb(v, addr) __readwrite_bug("writeb") 348*00f892fcSMacpaul Lin #define writew(v, addr) __readwrite_bug("writew") 349*00f892fcSMacpaul Lin #define writel(v, addr) __readwrite_bug("writel") 350*00f892fcSMacpaul Lin 351*00f892fcSMacpaul Lin #define eth_io_copy_and_sum(a, b, c, d) __readwrite_bug("eth_io_copy_and_sum") 352*00f892fcSMacpaul Lin 353*00f892fcSMacpaul Lin #define check_signature(io, sig, len) (0) 354*00f892fcSMacpaul Lin 355*00f892fcSMacpaul Lin #endif /* __mem_pci */ 356*00f892fcSMacpaul Lin 357*00f892fcSMacpaul Lin /* 358*00f892fcSMacpaul Lin * If this architecture has ISA IO, then define the isa_read/isa_write 359*00f892fcSMacpaul Lin * macros. 360*00f892fcSMacpaul Lin */ 361*00f892fcSMacpaul Lin #ifdef __mem_isa 362*00f892fcSMacpaul Lin 363*00f892fcSMacpaul Lin #define isa_readb(addr) __raw_readb(__mem_isa(addr)) 364*00f892fcSMacpaul Lin #define isa_readw(addr) __raw_readw(__mem_isa(addr)) 365*00f892fcSMacpaul Lin #define isa_readl(addr) __raw_readl(__mem_isa(addr)) 366*00f892fcSMacpaul Lin #define isa_writeb(val, addr) __raw_writeb(val, __mem_isa(addr)) 367*00f892fcSMacpaul Lin #define isa_writew(val, addr) __raw_writew(val, __mem_isa(addr)) 368*00f892fcSMacpaul Lin #define isa_writel(val, addr) __raw_writel(val, __mem_isa(addr)) 369*00f892fcSMacpaul Lin #define isa_memset_io(a, b, c) _memset_io(__mem_isa(a), (b), (c)) 370*00f892fcSMacpaul Lin #define isa_memcpy_fromio(a, b, c) _memcpy_fromio((a), __mem_isa(b), (c)) 371*00f892fcSMacpaul Lin #define isa_memcpy_toio(a, b, c) _memcpy_toio(__mem_isa((a)), (b), (c)) 372*00f892fcSMacpaul Lin 373*00f892fcSMacpaul Lin #define isa_eth_io_copy_and_sum(a, b, c, d) \ 374*00f892fcSMacpaul Lin eth_copy_and_sum((a), __mem_isa(b), (c), (d)) 375*00f892fcSMacpaul Lin 376*00f892fcSMacpaul Lin static inline int 377*00f892fcSMacpaul Lin isa_check_signature(unsigned long io_addr, const unsigned char *signature, 378*00f892fcSMacpaul Lin int length) 379*00f892fcSMacpaul Lin { 380*00f892fcSMacpaul Lin int retval = 0; 381*00f892fcSMacpaul Lin do { 382*00f892fcSMacpaul Lin if (isa_readb(io_addr) != *signature) 383*00f892fcSMacpaul Lin goto out; 384*00f892fcSMacpaul Lin io_addr++; 385*00f892fcSMacpaul Lin signature++; 386*00f892fcSMacpaul Lin length--; 387*00f892fcSMacpaul Lin } while (length); 388*00f892fcSMacpaul Lin retval = 1; 389*00f892fcSMacpaul Lin out: 390*00f892fcSMacpaul Lin return retval; 391*00f892fcSMacpaul Lin } 392*00f892fcSMacpaul Lin 393*00f892fcSMacpaul Lin #else /* __mem_isa */ 394*00f892fcSMacpaul Lin 395*00f892fcSMacpaul Lin #define isa_readb(addr) (__readwrite_bug("isa_readb"), 0) 396*00f892fcSMacpaul Lin #define isa_readw(addr) (__readwrite_bug("isa_readw"), 0) 397*00f892fcSMacpaul Lin #define isa_readl(addr) (__readwrite_bug("isa_readl"), 0) 398*00f892fcSMacpaul Lin #define isa_writeb(val, addr) __readwrite_bug("isa_writeb") 399*00f892fcSMacpaul Lin #define isa_writew(val, addr) __readwrite_bug("isa_writew") 400*00f892fcSMacpaul Lin #define isa_writel(val, addr) __readwrite_bug("isa_writel") 401*00f892fcSMacpaul Lin #define isa_memset_io(a, b, c) __readwrite_bug("isa_memset_io") 402*00f892fcSMacpaul Lin #define isa_memcpy_fromio(a, b, c) __readwrite_bug("isa_memcpy_fromio") 403*00f892fcSMacpaul Lin #define isa_memcpy_toio(a, b, c) __readwrite_bug("isa_memcpy_toio") 404*00f892fcSMacpaul Lin 405*00f892fcSMacpaul Lin #define isa_eth_io_copy_and_sum(a, b, c, d) \ 406*00f892fcSMacpaul Lin __readwrite_bug("isa_eth_io_copy_and_sum") 407*00f892fcSMacpaul Lin 408*00f892fcSMacpaul Lin #define isa_check_signature(io, sig, len) (0) 409*00f892fcSMacpaul Lin 410*00f892fcSMacpaul Lin #endif /* __mem_isa */ 411*00f892fcSMacpaul Lin #endif /* __KERNEL__ */ 412*00f892fcSMacpaul Lin #endif /* __ASM_NDS_IO_H */ 413