arch/arm/mach-ixp4xx/include/mach/io.h

   1 /*
   2  * arch/arm/mach-ixp4xx/include/mach/io.h
   3  *
   4  * Author: Deepak Saxena <dsaxena@plexity.net>
   5  *
   6  * Copyright (C) 2002-2005  MontaVista Software, Inc.
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 as
  10  * published by the Free Software Foundation.
  11  */
  12
  13 #ifndef __ASM_ARM_ARCH_IO_H
  14 #define __ASM_ARM_ARCH_IO_H
  15
  16 #include <linux/bitops.h>
  17
  18 #include <mach/hardware.h>
  19
  20 extern int (*ixp4xx_pci_read)(u32 addr, u32 cmd, u32* data);
  21 extern int ixp4xx_pci_write(u32 addr, u32 cmd, u32 data);
  22
  23
  24 /*
  25  * IXP4xx provides two methods of accessing PCI memory space:
  26  *
  27  * 1) A direct mapped window from 0x48000000 to 0x4BFFFFFF (64MB).
  28  *    To access PCI via this space, we simply ioremap() the BAR
  29  *    into the kernel and we can use the standard read[bwl]/write[bwl]
  30  *    macros. This is the preffered method due to speed but it
  31  *    limits the system to just 64MB of PCI memory. This can be
  32  *    problematic if using video cards and other memory-heavy targets.
  33  *
  34  * 2) If > 64MB of memory space is required, the IXP4xx can use indirect
  35  *    registers to access the whole 4 GB of PCI memory space (as we do below
  36  *    for I/O transactions). This allows currently for up to 1 GB (0x10000000
  37  *    to 0x4FFFFFFF) of memory on the bus. The disadvantage of this is that
  38  *    every PCI access requires three local register accesses plus a spinlock,
  39  *    but in some cases the performance hit is acceptable. In addition, you
  40  *    cannot mmap() PCI devices in this case.
  41  */
  42 #ifdef  CONFIG_IXP4XX_INDIRECT_PCI
  43
  44 /*
  45  * In the case of using indirect PCI, we simply return the actual PCI
  46  * address and our read/write implementation use that to drive the
  47  * access registers. If something outside of PCI is ioremap'd, we
  48  * fallback to the default.
  49  */
  50
  51 extern unsigned long pcibios_min_mem;
  52 static inline int is_pci_memory(u32 addr)
  53 {
  54         return (addr >= pcibios_min_mem) && (addr <= 0x4FFFFFFF);
  55 }
  56
  57 #define writeb(v, p)                    __indirect_writeb(v, p)
  58 #define writew(v, p)                    __indirect_writew(v, p)
  59 #define writel(v, p)                    __indirect_writel(v, p)
  60
  61 #define writeb_relaxed(v, p)            __indirect_writeb(v, p)
  62 #define writew_relaxed(v, p)            __indirect_writew(v, p)
  63 #define writel_relaxed(v, p)            __indirect_writel(v, p)
  64
  65 #define writesb(p, v, l)                __indirect_writesb(p, v, l)
  66 #define writesw(p, v, l)                __indirect_writesw(p, v, l)
  67 #define writesl(p, v, l)                __indirect_writesl(p, v, l)
  68
  69 #define readb(p)                        __indirect_readb(p)
  70 #define readw(p)                        __indirect_readw(p)
  71 #define readl(p)                        __indirect_readl(p)
  72
  73 #define readb_relaxed(p)                __indirect_readb(p)
  74 #define readw_relaxed(p)                __indirect_readw(p)
  75 #define readl_relaxed(p)                __indirect_readl(p)
  76
  77 #define readsb(p, v, l)                 __indirect_readsb(p, v, l)
  78 #define readsw(p, v, l)                 __indirect_readsw(p, v, l)
  79 #define readsl(p, v, l)                 __indirect_readsl(p, v, l)
  80
  81 static inline void __indirect_writeb(u8 value, volatile void __iomem *p)
  82 {
  83         u32 addr = (u32)p;
  84         u32 n, byte_enables, data;
  85
  86         if (!is_pci_memory(addr)) {
  87                 __raw_writeb(value, p);
  88                 return;
  89         }
  90
  91         n = addr % 4;
  92         byte_enables = (0xf & ~BIT(n)) << IXP4XX_PCI_NP_CBE_BESL;
  93         data = value << (8*n);
  94         ixp4xx_pci_write(addr, byte_enables | NP_CMD_MEMWRITE, data);
  95 }
  96
  97 static inline void __indirect_writesb(volatile void __iomem *bus_addr,
  98                                       const u8 *vaddr, int count)
  99 {
 100         while (count--)
 101                 writeb(*vaddr++, bus_addr);
 102 }
 103
 104 static inline void __indirect_writew(u16 value, volatile void __iomem *p)
 105 {
 106         u32 addr = (u32)p;
 107         u32 n, byte_enables, data;
 108
 109         if (!is_pci_memory(addr)) {
 110                 __raw_writew(value, p);
 111                 return;
 112         }
 113
 114         n = addr % 4;
 115         byte_enables = (0xf & ~(BIT(n) | BIT(n+1))) << IXP4XX_PCI_NP_CBE_BESL;
 116         data = value << (8*n);
 117         ixp4xx_pci_write(addr, byte_enables | NP_CMD_MEMWRITE, data);
 118 }
 119
 120 static inline void __indirect_writesw(volatile void __iomem *bus_addr,
 121                                       const u16 *vaddr, int count)
 122 {
 123         while (count--)
 124                 writew(*vaddr++, bus_addr);
 125 }
 126
 127 static inline void __indirect_writel(u32 value, volatile void __iomem *p)
 128 {
 129         u32 addr = (__force u32)p;
 130
 131         if (!is_pci_memory(addr)) {
 132                 __raw_writel(value, p);
 133                 return;
 134         }
 135
 136         ixp4xx_pci_write(addr, NP_CMD_MEMWRITE, value);
 137 }
 138
 139 static inline void __indirect_writesl(volatile void __iomem *bus_addr,
 140                                       const u32 *vaddr, int count)
 141 {
 142         while (count--)
 143                 writel(*vaddr++, bus_addr);
 144 }
 145
 146 static inline unsigned char __indirect_readb(const volatile void __iomem *p)
 147 {
 148         u32 addr = (u32)p;
 149         u32 n, byte_enables, data;
 150
 151         if (!is_pci_memory(addr))
 152                 return __raw_readb(p);
 153
 154         n = addr % 4;
 155         byte_enables = (0xf & ~BIT(n)) << IXP4XX_PCI_NP_CBE_BESL;
 156         if (ixp4xx_pci_read(addr, byte_enables | NP_CMD_MEMREAD, &data))
 157                 return 0xff;
 158
 159         return data >> (8*n);
 160 }
 161
 162 static inline void __indirect_readsb(const volatile void __iomem *bus_addr,
 163                                      u8 *vaddr, u32 count)
 164 {
 165         while (count--)
 166                 *vaddr++ = readb(bus_addr);
 167 }
 168
 169 static inline unsigned short __indirect_readw(const volatile void __iomem *p)
 170 {
 171         u32 addr = (u32)p;
 172         u32 n, byte_enables, data;
 173
 174         if (!is_pci_memory(addr))
 175                 return __raw_readw(p);
 176
 177         n = addr % 4;
 178         byte_enables = (0xf & ~(BIT(n) | BIT(n+1))) << IXP4XX_PCI_NP_CBE_BESL;
 179         if (ixp4xx_pci_read(addr, byte_enables | NP_CMD_MEMREAD, &data))
 180                 return 0xffff;
 181
 182         return data>>(8*n);
 183 }
 184
 185 static inline void __indirect_readsw(const volatile void __iomem *bus_addr,
 186                                      u16 *vaddr, u32 count)
 187 {
 188         while (count--)
 189                 *vaddr++ = readw(bus_addr);
 190 }
 191
 192 static inline unsigned long __indirect_readl(const volatile void __iomem *p)
 193 {
 194         u32 addr = (__force u32)p;
 195         u32 data;
 196
 197         if (!is_pci_memory(addr))
 198                 return __raw_readl(p);
 199
 200         if (ixp4xx_pci_read(addr, NP_CMD_MEMREAD, &data))
 201                 return 0xffffffff;
 202
 203         return data;
 204 }
 205
 206 static inline void __indirect_readsl(const volatile void __iomem *bus_addr,
 207                                      u32 *vaddr, u32 count)
 208 {
 209         while (count--)
 210                 *vaddr++ = readl(bus_addr);
 211 }
 212
 213
 214 /*
 215  * We can use the built-in functions b/c they end up calling writeb/readb
 216  */
 217 #define memset_io(c,v,l)                _memset_io((c),(v),(l))
 218 #define memcpy_fromio(a,c,l)            _memcpy_fromio((a),(c),(l))
 219 #define memcpy_toio(c,a,l)              _memcpy_toio((c),(a),(l))
 220
 221 #endif /* CONFIG_IXP4XX_INDIRECT_PCI */
 222
 223 #ifndef CONFIG_PCI
 224
 225 #define __io(v)         __typesafe_io(v)
 226
 227 #else
 228
 229 /*
 230  * IXP4xx does not have a transparent cpu -> PCI I/O translation
 231  * window.  Instead, it has a set of registers that must be tweaked
 232  * with the proper byte lanes, command types, and address for the
 233  * transaction.  This means that we need to override the default
 234  * I/O functions.
 235  */
 236
 237 #define outb outb
 238 static inline void outb(u8 value, u32 addr)
 239 {
 240         u32 n, byte_enables, data;
 241         n = addr % 4;
 242         byte_enables = (0xf & ~BIT(n)) << IXP4XX_PCI_NP_CBE_BESL;
 243         data = value << (8*n);
 244         ixp4xx_pci_write(addr, byte_enables | NP_CMD_IOWRITE, data);
 245 }
 246
 247 #define outsb outsb
 248 static inline void outsb(u32 io_addr, const u8 *vaddr, u32 count)
 249 {
 250         while (count--)
 251                 outb(*vaddr++, io_addr);
 252 }
 253
 254 #define outw outw
 255 static inline void outw(u16 value, u32 addr)
 256 {
 257         u32 n, byte_enables, data;
 258         n = addr % 4;
 259         byte_enables = (0xf & ~(BIT(n) | BIT(n+1))) << IXP4XX_PCI_NP_CBE_BESL;
 260         data = value << (8*n);
 261         ixp4xx_pci_write(addr, byte_enables | NP_CMD_IOWRITE, data);
 262 }
 263
 264 #define outsw outsw
 265 static inline void outsw(u32 io_addr, const u16 *vaddr, u32 count)
 266 {
 267         while (count--)
 268                 outw(cpu_to_le16(*vaddr++), io_addr);
 269 }
 270
 271 #define outl outl
 272 static inline void outl(u32 value, u32 addr)
 273 {
 274         ixp4xx_pci_write(addr, NP_CMD_IOWRITE, value);
 275 }
 276
 277 #define outsl outsl
 278 static inline void outsl(u32 io_addr, const u32 *vaddr, u32 count)
 279 {
 280         while (count--)
 281                 outl(cpu_to_le32(*vaddr++), io_addr);
 282 }
 283
 284 #define inb inb
 285 static inline u8 inb(u32 addr)
 286 {
 287         u32 n, byte_enables, data;
 288         n = addr % 4;
 289         byte_enables = (0xf & ~BIT(n)) << IXP4XX_PCI_NP_CBE_BESL;
 290         if (ixp4xx_pci_read(addr, byte_enables | NP_CMD_IOREAD, &data))
 291                 return 0xff;
 292
 293         return data >> (8*n);
 294 }
 295
 296 #define insb insb
 297 static inline void insb(u32 io_addr, u8 *vaddr, u32 count)
 298 {
 299         while (count--)
 300                 *vaddr++ = inb(io_addr);
 301 }
 302
 303 #define inw inw
 304 static inline u16 inw(u32 addr)
 305 {
 306         u32 n, byte_enables, data;
 307         n = addr % 4;
 308         byte_enables = (0xf & ~(BIT(n) | BIT(n+1))) << IXP4XX_PCI_NP_CBE_BESL;
 309         if (ixp4xx_pci_read(addr, byte_enables | NP_CMD_IOREAD, &data))
 310                 return 0xffff;
 311
 312         return data>>(8*n);
 313 }
 314
 315 #define insw insw
 316 static inline void insw(u32 io_addr, u16 *vaddr, u32 count)
 317 {
 318         while (count--)
 319                 *vaddr++ = le16_to_cpu(inw(io_addr));
 320 }
 321
 322 #define inl inl
 323 static inline u32 inl(u32 addr)
 324 {
 325         u32 data;
 326         if (ixp4xx_pci_read(addr, NP_CMD_IOREAD, &data))
 327                 return 0xffffffff;
 328
 329         return data;
 330 }
 331
 332 #define insl insl
 333 static inline void insl(u32 io_addr, u32 *vaddr, u32 count)
 334 {
 335         while (count--)
 336                 *vaddr++ = le32_to_cpu(inl(io_addr));
 337 }
 338
 339 #define PIO_OFFSET      0x10000UL
 340 #define PIO_MASK        0x0ffffUL
 341
 342 #define __is_io_address(p)      (((unsigned long)p >= PIO_OFFSET) && \
 343                                         ((unsigned long)p <= (PIO_MASK + PIO_OFFSET)))
 344
 345 #define ioread8(p)                      ioread8(p)
 346 static inline unsigned int ioread8(const void __iomem *addr)
 347 {
 348         unsigned long port = (unsigned long __force)addr;
 349         if (__is_io_address(port))
 350                 return (unsigned int)inb(port & PIO_MASK);
 351         else
 352 #ifndef CONFIG_IXP4XX_INDIRECT_PCI
 353                 return (unsigned int)__raw_readb(addr);
 354 #else
 355                 return (unsigned int)__indirect_readb(addr);
 356 #endif
 357 }
 358
 359 #define ioread8_rep(p, v, c)            ioread8_rep(p, v, c)
 360 static inline void ioread8_rep(const void __iomem *addr, void *vaddr, u32 count)
 361 {
 362         unsigned long port = (unsigned long __force)addr;
 363         if (__is_io_address(port))
 364                 insb(port & PIO_MASK, vaddr, count);
 365         else
 366 #ifndef CONFIG_IXP4XX_INDIRECT_PCI
 367                 __raw_readsb(addr, vaddr, count);
 368 #else
 369                 __indirect_readsb(addr, vaddr, count);
 370 #endif
 371 }
 372
 373 #define ioread16(p)                     ioread16(p)
 374 static inline unsigned int ioread16(const void __iomem *addr)
 375 {
 376         unsigned long port = (unsigned long __force)addr;
 377         if (__is_io_address(port))
 378                 return  (unsigned int)inw(port & PIO_MASK);
 379         else
 380 #ifndef CONFIG_IXP4XX_INDIRECT_PCI
 381                 return le16_to_cpu((__force __le16)__raw_readw(addr));
 382 #else
 383                 return (unsigned int)__indirect_readw(addr);
 384 #endif
 385 }
 386
 387 #define ioread16_rep(p, v, c)           ioread16_rep(p, v, c)
 388 static inline void ioread16_rep(const void __iomem *addr, void *vaddr,
 389                                 u32 count)
 390 {
 391         unsigned long port = (unsigned long __force)addr;
 392         if (__is_io_address(port))
 393                 insw(port & PIO_MASK, vaddr, count);
 394         else
 395 #ifndef CONFIG_IXP4XX_INDIRECT_PCI
 396                 __raw_readsw(addr, vaddr, count);
 397 #else
 398                 __indirect_readsw(addr, vaddr, count);
 399 #endif
 400 }
 401
 402 #define ioread32(p)                     ioread32(p)
 403 static inline unsigned int ioread32(const void __iomem *addr)
 404 {
 405         unsigned long port = (unsigned long __force)addr;
 406         if (__is_io_address(port))
 407                 return  (unsigned int)inl(port & PIO_MASK);
 408         else {
 409 #ifndef CONFIG_IXP4XX_INDIRECT_PCI
 410                 return le32_to_cpu((__force __le32)__raw_readl(addr));
 411 #else
 412                 return (unsigned int)__indirect_readl(addr);
 413 #endif
 414         }
 415 }
 416
 417 #define ioread32_rep(p, v, c)           ioread32_rep(p, v, c)
 418 static inline void ioread32_rep(const void __iomem *addr, void *vaddr,
 419                                 u32 count)
 420 {
 421         unsigned long port = (unsigned long __force)addr;
 422         if (__is_io_address(port))
 423                 insl(port & PIO_MASK, vaddr, count);
 424         else
 425 #ifndef CONFIG_IXP4XX_INDIRECT_PCI
 426                 __raw_readsl(addr, vaddr, count);
 427 #else
 428                 __indirect_readsl(addr, vaddr, count);
 429 #endif
 430 }
 431
 432 #define iowrite8(v, p)                  iowrite8(v, p)
 433 static inline void iowrite8(u8 value, void __iomem *addr)
 434 {
 435         unsigned long port = (unsigned long __force)addr;
 436         if (__is_io_address(port))
 437                 outb(value, port & PIO_MASK);
 438         else
 439 #ifndef CONFIG_IXP4XX_INDIRECT_PCI
 440                 __raw_writeb(value, addr);
 441 #else
 442                 __indirect_writeb(value, addr);
 443 #endif
 444 }
 445
 446 #define iowrite8_rep(p, v, c)           iowrite8_rep(p, v, c)
 447 static inline void iowrite8_rep(void __iomem *addr, const void *vaddr,
 448                                 u32 count)
 449 {
 450         unsigned long port = (unsigned long __force)addr;
 451         if (__is_io_address(port))
 452                 outsb(port & PIO_MASK, vaddr, count);
 453         else
 454 #ifndef CONFIG_IXP4XX_INDIRECT_PCI
 455                 __raw_writesb(addr, vaddr, count);
 456 #else
 457                 __indirect_writesb(addr, vaddr, count);
 458 #endif
 459 }
 460
 461 #define iowrite16(v, p)                 iowrite16(v, p)
 462 static inline void iowrite16(u16 value, void __iomem *addr)
 463 {
 464         unsigned long port = (unsigned long __force)addr;
 465         if (__is_io_address(port))
 466                 outw(value, port & PIO_MASK);
 467         else
 468 #ifndef CONFIG_IXP4XX_INDIRECT_PCI
 469                 __raw_writew(cpu_to_le16(value), addr);
 470 #else
 471                 __indirect_writew(value, addr);
 472 #endif
 473 }
 474
 475 #define iowrite16_rep(p, v, c)          iowrite16_rep(p, v, c)
 476 static inline void iowrite16_rep(void __iomem *addr, const void *vaddr,
 477                                  u32 count)
 478 {
 479         unsigned long port = (unsigned long __force)addr;
 480         if (__is_io_address(port))
 481                 outsw(port & PIO_MASK, vaddr, count);
 482         else
 483 #ifndef CONFIG_IXP4XX_INDIRECT_PCI
 484                 __raw_writesw(addr, vaddr, count);
 485 #else
 486                 __indirect_writesw(addr, vaddr, count);
 487 #endif
 488 }
 489
 490 #define iowrite32(v, p)                 iowrite32(v, p)
 491 static inline void iowrite32(u32 value, void __iomem *addr)
 492 {
 493         unsigned long port = (unsigned long __force)addr;
 494         if (__is_io_address(port))
 495                 outl(value, port & PIO_MASK);
 496         else
 497 #ifndef CONFIG_IXP4XX_INDIRECT_PCI
 498                 __raw_writel((u32 __force)cpu_to_le32(value), addr);
 499 #else
 500                 __indirect_writel(value, addr);
 501 #endif
 502 }
 503
 504 #define iowrite32_rep(p, v, c)          iowrite32_rep(p, v, c)
 505 static inline void iowrite32_rep(void __iomem *addr, const void *vaddr,
 506                                  u32 count)
 507 {
 508         unsigned long port = (unsigned long __force)addr;
 509         if (__is_io_address(port))
 510                 outsl(port & PIO_MASK, vaddr, count);
 511         else
 512 #ifndef CONFIG_IXP4XX_INDIRECT_PCI
 513                 __raw_writesl(addr, vaddr, count);
 514 #else
 515                 __indirect_writesl(addr, vaddr, count);
 516 #endif
 517 }
 518
 519 #define ioport_map(port, nr)            ((void __iomem*)(port + PIO_OFFSET))
 520 #define ioport_unmap(addr)
 521 #endif /* CONFIG_PCI */
 522
 523 #endif /* __ASM_ARM_ARCH_IO_H */