err.no Git - linux-2.6/blob - arch/ppc/syslib/mpc52xx_pci.c

   1 /*
   2  * arch/ppc/syslib/mpc52xx_pci.c
   3  *
   4  * PCI code for the Freescale MPC52xx embedded CPU.
   5  *
   6  *
   7  * Maintainer : Sylvain Munaut <tnt@246tNt.com>
   8  *
   9  * Copyright (C) 2004 Sylvain Munaut <tnt@246tNt.com>
  10  *
  11  * This file is licensed under the terms of the GNU General Public License
  12  * version 2. This program is licensed "as is" without any warranty of any
  13  * kind, whether express or implied.
  14  */
  15
  16 #include <linux/config.h>
  17
  18 #include <asm/pci.h>
  19
  20 #include <asm/mpc52xx.h>
  21 #include "mpc52xx_pci.h"
  22
  23 #include <asm/delay.h>
  24 #include <asm/machdep.h>
  25
  26
  27 /* This macro is defined to activate the workaround for the bug
  28    435 of the MPC5200 (L25R). With it activated, we don't do any
  29    32 bits configuration access during type-1 cycles */
  30 #define MPC5200_BUG_435_WORKAROUND
  31
  32
  33 static int
  34 mpc52xx_pci_read_config(struct pci_bus *bus, unsigned int devfn,
  35                                 int offset, int len, u32 *val)
  36 {
  37         struct pci_controller *hose = bus->sysdata;
  38         u32 value;
  39
  40         if (ppc_md.pci_exclude_device)
  41                 if (ppc_md.pci_exclude_device(bus->number, devfn))
  42                         return PCIBIOS_DEVICE_NOT_FOUND;
  43
  44         out_be32(hose->cfg_addr,
  45                 (1 << 31) |
  46                 ((bus->number - hose->bus_offset) << 16) |
  47                 (devfn << 8) |
  48                 (offset & 0xfc));
  49         mb();
  50
  51 #ifdef MPC5200_BUG_435_WORKAROUND
  52         if (bus->number != hose->bus_offset) {
  53                 switch (len) {
  54                         case 1:
  55                                 value = in_8(((u8 __iomem *)hose->cfg_data) + (offset & 3));
  56                                 break;
  57                         case 2:
  58                                 value = in_le16(((u16 __iomem *)hose->cfg_data) + ((offset>>1) & 1));
  59                                 break;
  60
  61                         default:
  62                                 value = in_le16((u16 __iomem *)hose->cfg_data) |
  63                                         (in_le16(((u16 __iomem *)hose->cfg_data) + 1) << 16);
  64                                 break;
  65                 }
  66         }
  67         else
  68 #endif
  69         {
  70                 value = in_le32(hose->cfg_data);
  71
  72                 if (len != 4) {
  73                         value >>= ((offset & 0x3) << 3);
  74                         value &= 0xffffffff >> (32 - (len << 3));
  75                 }
  76         }
  77
  78         *val = value;
  79
  80         out_be32(hose->cfg_addr, 0);
  81         mb();
  82
  83         return PCIBIOS_SUCCESSFUL;
  84 }
  85
  86 static int
  87 mpc52xx_pci_write_config(struct pci_bus *bus, unsigned int devfn,
  88                                 int offset, int len, u32 val)
  89 {
  90         struct pci_controller *hose = bus->sysdata;
  91         u32 value, mask;
  92
  93         if (ppc_md.pci_exclude_device)
  94                 if (ppc_md.pci_exclude_device(bus->number, devfn))
  95                         return PCIBIOS_DEVICE_NOT_FOUND;
  96
  97         out_be32(hose->cfg_addr,
  98                 (1 << 31) |
  99                 ((bus->number - hose->bus_offset) << 16) |
 100                 (devfn << 8) |
 101                 (offset & 0xfc));
 102         mb();
 103
 104 #ifdef MPC5200_BUG_435_WORKAROUND
 105         if (bus->number != hose->bus_offset) {
 106                 switch (len) {
 107                         case 1:
 108                                 out_8(((u8 __iomem *)hose->cfg_data) +
 109                                         (offset & 3), val);
 110                                 break;
 111                         case 2:
 112                                 out_le16(((u16 __iomem *)hose->cfg_data) +
 113                                         ((offset>>1) & 1), val);
 114                                 break;
 115
 116                         default:
 117                                 out_le16((u16 __iomem *)hose->cfg_data,
 118                                         (u16)val);
 119                                 out_le16(((u16 __iomem *)hose->cfg_data) + 1,
 120                                         (u16)(val>>16));
 121                                 break;
 122                 }
 123         }
 124         else
 125 #endif
 126         {
 127                 if (len != 4) {
 128                         value = in_le32(hose->cfg_data);
 129
 130                         offset = (offset & 0x3) << 3;
 131                         mask = (0xffffffff >> (32 - (len << 3)));
 132                         mask <<= offset;
 133
 134                         value &= ~mask;
 135                         val = value | ((val << offset) & mask);
 136                 }
 137
 138                 out_le32(hose->cfg_data, val);
 139         }
 140         mb();
 141
 142         out_be32(hose->cfg_addr, 0);
 143         mb();
 144
 145         return PCIBIOS_SUCCESSFUL;
 146 }
 147
 148 static struct pci_ops mpc52xx_pci_ops = {
 149         .read  = mpc52xx_pci_read_config,
 150         .write = mpc52xx_pci_write_config
 151 };
 152
 153
 154 static void __init
 155 mpc52xx_pci_setup(struct mpc52xx_pci __iomem *pci_regs)
 156 {
 157
 158         /* Setup control regs */
 159                 /* Nothing to do afaik */
 160
 161         /* Setup windows */
 162         out_be32(&pci_regs->iw0btar, MPC52xx_PCI_IWBTAR_TRANSLATION(
 163                 MPC52xx_PCI_MEM_START + MPC52xx_PCI_MEM_OFFSET,
 164                 MPC52xx_PCI_MEM_START,
 165                 MPC52xx_PCI_MEM_SIZE ));
 166
 167         out_be32(&pci_regs->iw1btar, MPC52xx_PCI_IWBTAR_TRANSLATION(
 168                 MPC52xx_PCI_MMIO_START + MPC52xx_PCI_MEM_OFFSET,
 169                 MPC52xx_PCI_MMIO_START,
 170                 MPC52xx_PCI_MMIO_SIZE ));
 171
 172         out_be32(&pci_regs->iw2btar, MPC52xx_PCI_IWBTAR_TRANSLATION(
 173                 MPC52xx_PCI_IO_BASE,
 174                 MPC52xx_PCI_IO_START,
 175                 MPC52xx_PCI_IO_SIZE ));
 176
 177         out_be32(&pci_regs->iwcr, MPC52xx_PCI_IWCR_PACK(
 178                 ( MPC52xx_PCI_IWCR_ENABLE |             /* iw0btar */
 179                   MPC52xx_PCI_IWCR_READ_MULTI |
 180                   MPC52xx_PCI_IWCR_MEM ),
 181                 ( MPC52xx_PCI_IWCR_ENABLE |             /* iw1btar */
 182                   MPC52xx_PCI_IWCR_READ |
 183                   MPC52xx_PCI_IWCR_MEM ),
 184                 ( MPC52xx_PCI_IWCR_ENABLE |             /* iw2btar */
 185                   MPC52xx_PCI_IWCR_IO )
 186         ));
 187
 188
 189         out_be32(&pci_regs->tbatr0,
 190                 MPC52xx_PCI_TBATR_ENABLE | MPC52xx_PCI_TARGET_IO );
 191         out_be32(&pci_regs->tbatr1,
 192                 MPC52xx_PCI_TBATR_ENABLE | MPC52xx_PCI_TARGET_MEM );
 193
 194         out_be32(&pci_regs->tcr, MPC52xx_PCI_TCR_LD);
 195
 196         /* Reset the exteral bus ( internal PCI controller is NOT resetted ) */
 197         /* Not necessary and can be a bad thing if for example the bootloader
 198            is displaying a splash screen or ... Just left here for
 199            documentation purpose if anyone need it */
 200 #if 0
 201         u32 tmp;
 202         tmp = in_be32(&pci_regs->gscr);
 203         out_be32(&pci_regs->gscr, tmp | MPC52xx_PCI_GSCR_PR);
 204         udelay(50);
 205         out_be32(&pci_regs->gscr, tmp);
 206 #endif
 207 }
 208
 209 static void
 210 mpc52xx_pci_fixup_resources(struct pci_dev *dev)
 211 {
 212         int i;
 213
 214         /* We don't rely on boot loader for PCI and resets all
 215            devices */
 216         for (i = 0; i < DEVICE_COUNT_RESOURCE; i++) {
 217                 struct resource *res = &dev->resource[i];
 218                 if (res->end > res->start) {    /* Only valid resources */
 219                         res->end -= res->start;
 220                         res->start = 0;
 221                         res->flags |= IORESOURCE_UNSET;
 222                 }
 223         }
 224
 225         /* The PCI Host bridge of MPC52xx has a prefetch memory resource
 226            fixed to 1Gb. Doesn't fit in the resource system so we remove it */
 227         if ( (dev->vendor == PCI_VENDOR_ID_MOTOROLA) &&
 228              (dev->device == PCI_DEVICE_ID_MOTOROLA_MPC5200) ) {
 229                 struct resource *res = &dev->resource[1];
 230                 res->start = res->end = res->flags = 0;
 231         }
 232 }
 233
 234 void __init
 235 mpc52xx_find_bridges(void)
 236 {
 237         struct mpc52xx_pci __iomem *pci_regs;
 238         struct pci_controller *hose;
 239
 240         pci_assign_all_buses = 1;
 241
 242         pci_regs = ioremap(MPC52xx_PA(MPC52xx_PCI_OFFSET), MPC52xx_PCI_SIZE);
 243         if (!pci_regs)
 244                 return;
 245
 246         hose = pcibios_alloc_controller();
 247         if (!hose) {
 248                 iounmap(pci_regs);
 249                 return;
 250         }
 251
 252         ppc_md.pci_swizzle = common_swizzle;
 253         ppc_md.pcibios_fixup_resources = mpc52xx_pci_fixup_resources;
 254
 255         hose->first_busno = 0;
 256         hose->last_busno = 0xff;
 257         hose->bus_offset = 0;
 258         hose->ops = &mpc52xx_pci_ops;
 259
 260         mpc52xx_pci_setup(pci_regs);
 261
 262         hose->pci_mem_offset = MPC52xx_PCI_MEM_OFFSET;
 263
 264         hose->io_base_virt = ioremap(MPC52xx_PCI_IO_BASE, MPC52xx_PCI_IO_SIZE);
 265         isa_io_base = (unsigned long) hose->io_base_virt;
 266
 267         hose->cfg_addr = &pci_regs->car;
 268         hose->cfg_data = hose->io_base_virt;
 269
 270         /* Setup resources */
 271         pci_init_resource(&hose->mem_resources[0],
 272                         MPC52xx_PCI_MEM_START,
 273                         MPC52xx_PCI_MEM_STOP,
 274                         IORESOURCE_MEM|IORESOURCE_PREFETCH,
 275                         "PCI prefetchable memory");
 276
 277         pci_init_resource(&hose->mem_resources[1],
 278                         MPC52xx_PCI_MMIO_START,
 279                         MPC52xx_PCI_MMIO_STOP,
 280                         IORESOURCE_MEM,
 281                         "PCI memory");
 282
 283         pci_init_resource(&hose->io_resource,
 284                         MPC52xx_PCI_IO_START,
 285                         MPC52xx_PCI_IO_STOP,
 286                         IORESOURCE_IO,
 287                         "PCI I/O");
 288
 289 }