err.no Git - linux-2.6/blob - include/asm-arm/arch-ixp4xx/io.h

   1 /*
   2  * linux/include/asm-arm/arch-ixp4xx/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 <asm/hardware.h>
  17
  18 #define IO_SPACE_LIMIT 0xffff0000
  19
  20 #define BIT(x)  ((1)<<(x))
  21
  22
  23 extern int (*ixp4xx_pci_read)(u32 addr, u32 cmd, u32* data);
  24 extern int ixp4xx_pci_write(u32 addr, u32 cmd, u32 data);
  25
  26
  27 /*
  28  * IXP4xx provides two methods of accessing PCI memory space:
  29  *
  30  * 1) A direct mapped window from 0x48000000 to 0x4bffffff (64MB).
  31  *    To access PCI via this space, we simply ioremap() the BAR
  32  *    into the kernel and we can use the standard read[bwl]/write[bwl]
  33  *    macros. This is the preffered method due to speed but it
  34  *    limits the system to just 64MB of PCI memory. This can be
  35  *    problamatic if using video cards and other memory-heavy
  36  *    targets.
  37  *
  38  * 2) If > 64MB of memory space is required, the IXP4xx can be configured
  39  *    to use indirect registers to access PCI (as we do below for I/O
  40  *    transactions). This allows for up to 128MB (0x48000000 to 0x4fffffff)
  41  *    of memory on the bus. The disadvantadge of this is that every
  42  *    PCI access requires three local register accesses plus a spinlock,
  43  *    but in some cases the performance hit is acceptable. In addition,
  44  *    you cannot mmap() PCI devices in this case.
  45  *
  46  */
  47 #ifndef CONFIG_IXP4XX_INDIRECT_PCI
  48
  49 #define __mem_pci(a)            (a)
  50
  51 #else
  52
  53 #include <linux/mm.h>
  54
  55 /*
  56  * In the case of using indirect PCI, we simply return the actual PCI
  57  * address and our read/write implementation use that to drive the
  58  * access registers. If something outside of PCI is ioremap'd, we
  59  * fallback to the default.
  60  */
  61 static inline void __iomem *
  62 __ixp4xx_ioremap(unsigned long addr, size_t size, unsigned long flags, unsigned long align)
  63 {
  64         extern void __iomem * __ioremap(unsigned long, size_t, unsigned long, unsigned long);
  65         if((addr < 0x48000000) || (addr > 0x4fffffff))
  66                 return __ioremap(addr, size, flags, align);
  67
  68         return (void *)addr;
  69 }
  70
  71 static inline void
  72 __ixp4xx_iounmap(void __iomem *addr)
  73 {
  74         extern void __iounmap(void __iomem *addr);
  75
  76         if ((u32)addr >= VMALLOC_START)
  77                 __iounmap(addr);
  78 }
  79
  80 #define __arch_ioremap(a, s, f, x)      __ixp4xx_ioremap(a, s, f, x)
  81 #define __arch_iounmap(a)               __ixp4xx_iounmap(a)
  82
  83 #define writeb(p, v)                    __ixp4xx_writeb(p, v)
  84 #define writew(p, v)                    __ixp4xx_writew(p, v)
  85 #define writel(p, v)                    __ixp4xx_writel(p, v)
  86
  87 #define writesb(p, v, l)                __ixp4xx_writesb(p, v, l)
  88 #define writesw(p, v, l)                __ixp4xx_writesw(p, v, l)
  89 #define writesl(p, v, l)                __ixp4xx_writesl(p, v, l)
  90
  91 #define readb(p)                        __ixp4xx_readb(p)
  92 #define readw(p)                        __ixp4xx_readw(p)
  93 #define readl(p)                        __ixp4xx_readl(p)
  94
  95 #define readsb(p, v, l)                 __ixp4xx_readsb(p, v, l)
  96 #define readsw(p, v, l)                 __ixp4xx_readsw(p, v, l)
  97 #define readsl(p, v, l)                 __ixp4xx_readsl(p, v, l)
  98
  99 static inline void
 100 __ixp4xx_writeb(u8 value, u32 addr)
 101 {
 102         u32 n, byte_enables, data;
 103
 104         if (addr >= VMALLOC_START) {
 105                 __raw_writeb(value, addr);
 106                 return;
 107         }
 108
 109         n = addr % 4;
 110         byte_enables = (0xf & ~BIT(n)) << IXP4XX_PCI_NP_CBE_BESL;
 111         data = value << (8*n);
 112         ixp4xx_pci_write(addr, byte_enables | NP_CMD_MEMWRITE, data);
 113 }
 114
 115 static inline void
 116 __ixp4xx_writesb(u32 bus_addr, u8 *vaddr, int count)
 117 {
 118         while (count--)
 119                 writeb(*vaddr++, bus_addr);
 120 }
 121
 122 static inline void
 123 __ixp4xx_writew(u16 value, u32 addr)
 124 {
 125         u32 n, byte_enables, data;
 126
 127         if (addr >= VMALLOC_START) {
 128                 __raw_writew(value, addr);
 129                 return;
 130         }
 131
 132         n = addr % 4;
 133         byte_enables = (0xf & ~(BIT(n) | BIT(n+1))) << IXP4XX_PCI_NP_CBE_BESL;
 134         data = value << (8*n);
 135         ixp4xx_pci_write(addr, byte_enables | NP_CMD_MEMWRITE, data);
 136 }
 137
 138 static inline void
 139 __ixp4xx_writesw(u32 bus_addr, u16 *vaddr, int count)
 140 {
 141         while (count--)
 142                 writew(*vaddr++, bus_addr);
 143 }
 144
 145 static inline void
 146 __ixp4xx_writel(u32 value, u32 addr)
 147 {
 148         if (addr >= VMALLOC_START) {
 149                 __raw_writel(value, addr);
 150                 return;
 151         }
 152
 153         ixp4xx_pci_write(addr, NP_CMD_MEMWRITE, value);
 154 }
 155
 156 static inline void
 157 __ixp4xx_writesl(u32 bus_addr, u32 *vaddr, int count)
 158 {
 159         while (count--)
 160                 writel(*vaddr++, bus_addr);
 161 }
 162
 163 static inline unsigned char
 164 __ixp4xx_readb(u32 addr)
 165 {
 166         u32 n, byte_enables, data;
 167
 168         if (addr >= VMALLOC_START)
 169                 return __raw_readb(addr);
 170
 171         n = addr % 4;
 172         byte_enables = (0xf & ~BIT(n)) << IXP4XX_PCI_NP_CBE_BESL;
 173         if (ixp4xx_pci_read(addr, byte_enables | NP_CMD_MEMREAD, &data))
 174                 return 0xff;
 175
 176         return data >> (8*n);
 177 }
 178
 179 static inline void
 180 __ixp4xx_readsb(u32 bus_addr, u8 *vaddr, u32 count)
 181 {
 182         while (count--)
 183                 *vaddr++ = readb(bus_addr);
 184 }
 185
 186 static inline unsigned short
 187 __ixp4xx_readw(u32 addr)
 188 {
 189         u32 n, byte_enables, data;
 190
 191         if (addr >= VMALLOC_START)
 192                 return __raw_readw(addr);
 193
 194         n = addr % 4;
 195         byte_enables = (0xf & ~(BIT(n) | BIT(n+1))) << IXP4XX_PCI_NP_CBE_BESL;
 196         if (ixp4xx_pci_read(addr, byte_enables | NP_CMD_MEMREAD, &data))
 197                 return 0xffff;
 198
 199         return data>>(8*n);
 200 }
 201
 202 static inline void
 203 __ixp4xx_readsw(u32 bus_addr, u16 *vaddr, u32 count)
 204 {
 205         while (count--)
 206                 *vaddr++ = readw(bus_addr);
 207 }
 208
 209 static inline unsigned long
 210 __ixp4xx_readl(u32 addr)
 211 {
 212         u32 data;
 213
 214         if (addr >= VMALLOC_START)
 215                 return __raw_readl(addr);
 216
 217         if (ixp4xx_pci_read(addr, NP_CMD_MEMREAD, &data))
 218                 return 0xffffffff;
 219
 220         return data;
 221 }
 222
 223 static inline void
 224 __ixp4xx_readsl(u32 bus_addr, u32 *vaddr, u32 count)
 225 {
 226         while (count--)
 227                 *vaddr++ = readl(bus_addr);
 228 }
 229
 230
 231 /*
 232  * We can use the built-in functions b/c they end up calling writeb/readb
 233  */
 234 #define memset_io(c,v,l)                _memset_io((c),(v),(l))
 235 #define memcpy_fromio(a,c,l)            _memcpy_fromio((a),(c),(l))
 236 #define memcpy_toio(c,a,l)              _memcpy_toio((c),(a),(l))
 237
 238 #define eth_io_copy_and_sum(s,c,l,b) \
 239                                 eth_copy_and_sum((s),__mem_pci(c),(l),(b))
 240
 241 static inline int
 242 check_signature(unsigned long bus_addr, const unsigned char *signature,
 243                 int length)
 244 {
 245         int retval = 0;
 246         do {
 247                 if (readb(bus_addr) != *signature)
 248                         goto out;
 249                 bus_addr++;
 250                 signature++;
 251                 length--;
 252         } while (length);
 253         retval = 1;
 254 out:
 255         return retval;
 256 }
 257
 258 #endif
 259
 260 /*
 261  * IXP4xx does not have a transparent cpu -> PCI I/O translation
 262  * window.  Instead, it has a set of registers that must be tweaked
 263  * with the proper byte lanes, command types, and address for the
 264  * transaction.  This means that we need to override the default
 265  * I/O functions.
 266  */
 267 #define outb(p, v)                      __ixp4xx_outb(p, v)
 268 #define outw(p, v)                      __ixp4xx_outw(p, v)
 269 #define outl(p, v)                      __ixp4xx_outl(p, v)
 270
 271 #define outsb(p, v, l)                  __ixp4xx_outsb(p, v, l)
 272 #define outsw(p, v, l)                  __ixp4xx_outsw(p, v, l)
 273 #define outsl(p, v, l)                  __ixp4xx_outsl(p, v, l)
 274
 275 #define inb(p)                          __ixp4xx_inb(p)
 276 #define inw(p)                          __ixp4xx_inw(p)
 277 #define inl(p)                          __ixp4xx_inl(p)
 278
 279 #define insb(p, v, l)                   __ixp4xx_insb(p, v, l)
 280 #define insw(p, v, l)                   __ixp4xx_insw(p, v, l)
 281 #define insl(p, v, l)                   __ixp4xx_insl(p, v, l)
 282
 283
 284 static inline void
 285 __ixp4xx_outb(u8 value, 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         data = value << (8*n);
 291         ixp4xx_pci_write(addr, byte_enables | NP_CMD_IOWRITE, data);
 292 }
 293
 294 static inline void
 295 __ixp4xx_outsb(u32 io_addr, const u8 *vaddr, u32 count)
 296 {
 297         while (count--)
 298                 outb(*vaddr++, io_addr);
 299 }
 300
 301 static inline void
 302 __ixp4xx_outw(u16 value, u32 addr)
 303 {
 304         u32 n, byte_enables, data;
 305         n = addr % 4;
 306         byte_enables = (0xf & ~(BIT(n) | BIT(n+1))) << IXP4XX_PCI_NP_CBE_BESL;
 307         data = value << (8*n);
 308         ixp4xx_pci_write(addr, byte_enables | NP_CMD_IOWRITE, data);
 309 }
 310
 311 static inline void
 312 __ixp4xx_outsw(u32 io_addr, const u16 *vaddr, u32 count)
 313 {
 314         while (count--)
 315                 outw(cpu_to_le16(*vaddr++), io_addr);
 316 }
 317
 318 static inline void
 319 __ixp4xx_outl(u32 value, u32 addr)
 320 {
 321         ixp4xx_pci_write(addr, NP_CMD_IOWRITE, value);
 322 }
 323
 324 static inline void
 325 __ixp4xx_outsl(u32 io_addr, const u32 *vaddr, u32 count)
 326 {
 327         while (count--)
 328                 outl(*vaddr++, io_addr);
 329 }
 330
 331 static inline u8
 332 __ixp4xx_inb(u32 addr)
 333 {
 334         u32 n, byte_enables, data;
 335         n = addr % 4;
 336         byte_enables = (0xf & ~BIT(n)) << IXP4XX_PCI_NP_CBE_BESL;
 337         if (ixp4xx_pci_read(addr, byte_enables | NP_CMD_IOREAD, &data))
 338                 return 0xff;
 339
 340         return data >> (8*n);
 341 }
 342
 343 static inline void
 344 __ixp4xx_insb(u32 io_addr, u8 *vaddr, u32 count)
 345 {
 346         while (count--)
 347                 *vaddr++ = inb(io_addr);
 348 }
 349
 350 static inline u16
 351 __ixp4xx_inw(u32 addr)
 352 {
 353         u32 n, byte_enables, data;
 354         n = addr % 4;
 355         byte_enables = (0xf & ~(BIT(n) | BIT(n+1))) << IXP4XX_PCI_NP_CBE_BESL;
 356         if (ixp4xx_pci_read(addr, byte_enables | NP_CMD_IOREAD, &data))
 357                 return 0xffff;
 358
 359         return data>>(8*n);
 360 }
 361
 362 static inline void
 363 __ixp4xx_insw(u32 io_addr, u16 *vaddr, u32 count)
 364 {
 365         while (count--)
 366                 *vaddr++ = le16_to_cpu(inw(io_addr));
 367 }
 368
 369 static inline u32
 370 __ixp4xx_inl(u32 addr)
 371 {
 372         u32 data;
 373         if (ixp4xx_pci_read(addr, NP_CMD_IOREAD, &data))
 374                 return 0xffffffff;
 375
 376         return data;
 377 }
 378
 379 static inline void
 380 __ixp4xx_insl(u32 io_addr, u32 *vaddr, u32 count)
 381 {
 382         while (count--)
 383                 *vaddr++ = inl(io_addr);
 384 }
 385
 386 #define __is_io_address(p)      (((unsigned long)p >= 0x0) && \
 387                                         ((unsigned long)p <= 0x0000ffff))
 388 static inline unsigned int
 389 __ixp4xx_ioread8(void __iomem *port)
 390 {
 391         if (__is_io_address(port))
 392                 return  (unsigned int)__ixp4xx_inb((unsigned int)port);
 393         else
 394 #ifndef CONFIG_IXP4XX_INDIRECT_PCI
 395                 return (unsigned int)__raw_readb((u32)port);
 396 #else
 397                 return (unsigned int)__ixp4xx_readb((u32)port);
 398 #endif
 399 }
 400
 401 static inline void
 402 __ixp4xx_ioread8_rep(u32 port, u8 *vaddr, u32 count)
 403 {
 404         if (__is_io_address(port))
 405                 __ixp4xx_insb(port, vaddr, count);
 406         else
 407 #ifndef CONFIG_IXP4XX_INDIRECT_PCI
 408                 __raw_readsb((void __iomem *)port, vaddr, count);
 409 #else
 410                 __ixp4xx_readsb(port, vaddr, count);
 411 #endif
 412 }
 413
 414 static inline unsigned int
 415 __ixp4xx_ioread16(void __iomem *port)
 416 {
 417         if (__is_io_address(port))
 418                 return  (unsigned int)__ixp4xx_inw((unsigned int)port);
 419         else
 420 #ifndef CONFIG_IXP4XX_INDIRECT_PCI
 421                 return le16_to_cpu(__raw_readw((u32)port));
 422 #else
 423                 return (unsigned int)__ixp4xx_readw((u32)port);
 424 #endif
 425 }
 426
 427 static inline void
 428 __ixp4xx_ioread16_rep(u32 port, u16 *vaddr, u32 count)
 429 {
 430         if (__is_io_address(port))
 431                 __ixp4xx_insw(port, vaddr, count);
 432         else
 433 #ifndef CONFIG_IXP4XX_INDIRECT_PCI
 434                 __raw_readsw((void __iomem *)port, vaddr, count);
 435 #else
 436                 __ixp4xx_readsw(port, vaddr, count);
 437 #endif
 438 }
 439
 440 static inline unsigned int
 441 __ixp4xx_ioread32(void __iomem *port)
 442 {
 443         if (__is_io_address(port))
 444                 return  (unsigned int)__ixp4xx_inl((unsigned int)port);
 445         else {
 446 #ifndef CONFIG_IXP4XX_INDIRECT_PCI
 447                 return le32_to_cpu(__raw_readl((u32)port));
 448 #else
 449                 return (unsigned int)__ixp4xx_readl((u32)port);
 450 #endif
 451         }
 452 }
 453
 454 static inline void
 455 __ixp4xx_ioread32_rep(u32 port, u32 *vaddr, u32 count)
 456 {
 457         if (__is_io_address(port))
 458                 __ixp4xx_insl(port, vaddr, count);
 459         else
 460 #ifndef CONFIG_IXP4XX_INDIRECT_PCI
 461                 __raw_readsl((void __iomem *)port, vaddr, count);
 462 #else
 463                 __ixp4xx_readsl(port, vaddr, count);
 464 #endif
 465 }
 466
 467 static inline void
 468 __ixp4xx_iowrite8(u8 value, void __iomem *port)
 469 {
 470         if (__is_io_address(port))
 471                 __ixp4xx_outb(value, (unsigned int)port);
 472         else
 473 #ifndef CONFIG_IXP4XX_INDIRECT_PCI
 474                 __raw_writeb(value, (u32)port);
 475 #else
 476                 __ixp4xx_writeb(value, (u32)port);
 477 #endif
 478 }
 479
 480 static inline void
 481 __ixp4xx_iowrite8_rep(u32 port, u8 *vaddr, u32 count)
 482 {
 483         if (__is_io_address(port))
 484                 __ixp4xx_outsb(port, vaddr, count);
 485 #ifndef CONFIG_IXP4XX_INDIRECT_PCI
 486                 __raw_writesb((void __iomem *)port, vaddr, count);
 487 #else
 488                 __ixp4xx_writesb(port, vaddr, count);
 489 #endif
 490 }
 491
 492 static inline void
 493 __ixp4xx_iowrite16(u16 value, void __iomem *port)
 494 {
 495         if (__is_io_address(port))
 496                 __ixp4xx_outw(value, (unsigned int)port);
 497         else
 498 #ifndef CONFIG_IXP4XX_INDIRECT_PCI
 499                 __raw_writew(cpu_to_le16(value), (u32)port);
 500 #else
 501                 __ixp4xx_writew(value, (u32)port);
 502 #endif
 503 }
 504
 505 static inline void
 506 __ixp4xx_iowrite16_rep(u32 port, u16 *vaddr, u32 count)
 507 {
 508         if (__is_io_address(port))
 509                 __ixp4xx_outsw(port, vaddr, count);
 510 #ifndef CONFIG_IXP4XX_INDIRECT_PCI
 511                 __raw_readsw((void __iomem *)port, vaddr, count);
 512 #else
 513                 __ixp4xx_writesw(port, vaddr, count);
 514 #endif
 515 }
 516
 517 static inline void
 518 __ixp4xx_iowrite32(u32 value, void __iomem *port)
 519 {
 520         if (__is_io_address(port))
 521                 __ixp4xx_outl(value, (unsigned int)port);
 522         else
 523 #ifndef CONFIG_IXP4XX_INDIRECT_PCI
 524                 __raw_writel(cpu_to_le32(value), (u32)port);
 525 #else
 526                 __ixp4xx_writel(value, (u32)port);
 527 #endif
 528 }
 529
 530 static inline void
 531 __ixp4xx_iowrite32_rep(u32 port, u32 *vaddr, u32 count)
 532 {
 533         if (__is_io_address(port))
 534                 __ixp4xx_outsl(port, vaddr, count);
 535 #ifndef CONFIG_IXP4XX_INDIRECT_PCI
 536                 __raw_readsl((void __iomem *)port, vaddr, count);
 537 #else
 538                 __ixp4xx_outsl(port, vaddr, count);
 539 #endif
 540 }
 541
 542 #define ioread8(p)                      __ixp4xx_ioread8(p)
 543 #define ioread16(p)                     __ixp4xx_ioread16(p)
 544 #define ioread32(p)                     __ixp4xx_ioread32(p)
 545
 546 #define ioread8_rep(p, v, c)            __ixp4xx_ioread8_rep(p, v, c)
 547 #define ioread16_rep(p, v, c)           __ixp4xx_ioread16_rep(p, v, c)
 548 #define ioread32_rep(p, v, c)           __ixp4xx_ioread32_rep(p, v, c)
 549
 550 #define iowrite8(v,p)                   __ixp4xx_iowrite8(v,p)
 551 #define iowrite16(v,p)                  __ixp4xx_iowrite16(v,p)
 552 #define iowrite32(v,p)                  __ixp4xx_iowrite32(v,p)
 553
 554 #define iowrite8_rep(p, v, c)           __ixp4xx_iowrite8_rep(p, v, c)
 555 #define iowrite16_rep(p, v, c)          __ixp4xx_iowrite16_rep(p, v, c)
 556 #define iowrite32_rep(p, v, c)          __ixp4xx_iowrite32_rep(p, v, c)
 557
 558 #define ioport_map(port, nr)            ((void __iomem*)port)
 559 #define ioport_unmap(addr)
 560
 561 #endif  //  __ASM_ARM_ARCH_IO_H
 562