arch/sparc64/kernel/pci_fire.c

   1 /* pci_fire.c: Sun4u platform PCI-E controller support.
   2  *
   3  * Copyright (C) 2007 David S. Miller (davem@davemloft.net)
   4  */
   5 #include <linux/kernel.h>
   6 #include <linux/pci.h>
   7 #include <linux/slab.h>
   8 #include <linux/init.h>
   9
  10 #include <asm/oplib.h>
  11 #include <asm/prom.h>
  12
  13 #include "pci_impl.h"
  14
  15 #define fire_read(__reg) \
  16 ({      u64 __ret; \
  17         __asm__ __volatile__("ldxa [%1] %2, %0" \
  18                              : "=r" (__ret) \
  19                              : "r" (__reg), "i" (ASI_PHYS_BYPASS_EC_E) \
  20                              : "memory"); \
  21         __ret; \
  22 })
  23 #define fire_write(__reg, __val) \
  24         __asm__ __volatile__("stxa %0, [%1] %2" \
  25                              : /* no outputs */ \
  26                              : "r" (__val), "r" (__reg), \
  27                                "i" (ASI_PHYS_BYPASS_EC_E) \
  28                              : "memory")
  29
  30 static void pci_fire_scan_bus(struct pci_pbm_info *pbm)
  31 {
  32         pbm->pci_bus = pci_scan_one_pbm(pbm);
  33
  34         /* XXX register error interrupt handlers XXX */
  35 }
  36
  37 #define FIRE_IOMMU_CONTROL      0x40000UL
  38 #define FIRE_IOMMU_TSBBASE      0x40008UL
  39 #define FIRE_IOMMU_FLUSH        0x40100UL
  40 #define FIRE_IOMMU_FLUSHINV     0x40108UL
  41
  42 static int pci_fire_pbm_iommu_init(struct pci_pbm_info *pbm)
  43 {
  44         struct iommu *iommu = pbm->iommu;
  45         u32 vdma[2], dma_mask;
  46         u64 control;
  47         int tsbsize, err;
  48
  49         /* No virtual-dma property on these guys, use largest size.  */
  50         vdma[0] = 0xc0000000; /* base */
  51         vdma[1] = 0x40000000; /* size */
  52         dma_mask = 0xffffffff;
  53         tsbsize = 128;
  54
  55         /* Register addresses. */
  56         iommu->iommu_control  = pbm->pbm_regs + FIRE_IOMMU_CONTROL;
  57         iommu->iommu_tsbbase  = pbm->pbm_regs + FIRE_IOMMU_TSBBASE;
  58         iommu->iommu_flush    = pbm->pbm_regs + FIRE_IOMMU_FLUSH;
  59         iommu->iommu_flushinv = pbm->pbm_regs + FIRE_IOMMU_FLUSHINV;
  60
  61         /* We use the main control/status register of FIRE as the write
  62          * completion register.
  63          */
  64         iommu->write_complete_reg = pbm->controller_regs + 0x410000UL;
  65
  66         /*
  67          * Invalidate TLB Entries.
  68          */
  69         fire_write(iommu->iommu_flushinv, ~(u64)0);
  70
  71         err = iommu_table_init(iommu, tsbsize * 8 * 1024, vdma[0], dma_mask);
  72         if (err)
  73                 return err;
  74
  75         fire_write(iommu->iommu_tsbbase, __pa(iommu->page_table) | 0x7UL);
  76
  77         control = fire_read(iommu->iommu_control);
  78         control |= (0x00000400 /* TSB cache snoop enable */     |
  79                     0x00000300 /* Cache mode */                 |
  80                     0x00000002 /* Bypass enable */              |
  81                     0x00000001 /* Translation enable */);
  82         fire_write(iommu->iommu_control, control);
  83
  84         return 0;
  85 }
  86
  87 /* Based at pbm->controller_regs */
  88 #define FIRE_PARITY_CONTROL     0x470010UL
  89 #define  FIRE_PARITY_ENAB       0x8000000000000000UL
  90 #define FIRE_FATAL_RESET_CTL    0x471028UL
  91 #define  FIRE_FATAL_RESET_SPARE 0x0000000004000000UL
  92 #define  FIRE_FATAL_RESET_MB    0x0000000002000000UL
  93 #define  FIRE_FATAL_RESET_CPE   0x0000000000008000UL
  94 #define  FIRE_FATAL_RESET_APE   0x0000000000004000UL
  95 #define  FIRE_FATAL_RESET_PIO   0x0000000000000040UL
  96 #define  FIRE_FATAL_RESET_JW    0x0000000000000004UL
  97 #define  FIRE_FATAL_RESET_JI    0x0000000000000002UL
  98 #define  FIRE_FATAL_RESET_JR    0x0000000000000001UL
  99 #define FIRE_CORE_INTR_ENABLE   0x471800UL
 100
 101 /* Based at pbm->pbm_regs */
 102 #define FIRE_TLU_CTRL           0x80000UL
 103 #define  FIRE_TLU_CTRL_TIM      0x00000000da000000UL
 104 #define  FIRE_TLU_CTRL_QDET     0x0000000000000100UL
 105 #define  FIRE_TLU_CTRL_CFG      0x0000000000000001UL
 106 #define FIRE_TLU_DEV_CTRL       0x90008UL
 107 #define FIRE_TLU_LINK_CTRL      0x90020UL
 108 #define FIRE_TLU_LINK_CTRL_CLK  0x0000000000000040UL
 109 #define FIRE_LPU_RESET          0xe2008UL
 110 #define FIRE_LPU_LLCFG          0xe2200UL
 111 #define  FIRE_LPU_LLCFG_VC0     0x0000000000000100UL
 112 #define FIRE_LPU_FCTRL_UCTRL    0xe2240UL
 113 #define  FIRE_LPU_FCTRL_UCTRL_N 0x0000000000000002UL
 114 #define  FIRE_LPU_FCTRL_UCTRL_P 0x0000000000000001UL
 115 #define FIRE_LPU_TXL_FIFOP      0xe2430UL
 116 #define FIRE_LPU_LTSSM_CFG2     0xe2788UL
 117 #define FIRE_LPU_LTSSM_CFG3     0xe2790UL
 118 #define FIRE_LPU_LTSSM_CFG4     0xe2798UL
 119 #define FIRE_LPU_LTSSM_CFG5     0xe27a0UL
 120 #define FIRE_DMC_IENAB          0x31800UL
 121 #define FIRE_DMC_DBG_SEL_A      0x53000UL
 122 #define FIRE_DMC_DBG_SEL_B      0x53008UL
 123 #define FIRE_PEC_IENAB          0x51800UL
 124
 125 static void pci_fire_hw_init(struct pci_pbm_info *pbm)
 126 {
 127         u64 val;
 128
 129         fire_write(pbm->controller_regs + FIRE_PARITY_CONTROL,
 130                    FIRE_PARITY_ENAB);
 131
 132         fire_write(pbm->controller_regs + FIRE_FATAL_RESET_CTL,
 133                    (FIRE_FATAL_RESET_SPARE |
 134                     FIRE_FATAL_RESET_MB |
 135                     FIRE_FATAL_RESET_CPE |
 136                     FIRE_FATAL_RESET_APE |
 137                     FIRE_FATAL_RESET_PIO |
 138                     FIRE_FATAL_RESET_JW |
 139                     FIRE_FATAL_RESET_JI |
 140                     FIRE_FATAL_RESET_JR));
 141
 142         fire_write(pbm->controller_regs + FIRE_CORE_INTR_ENABLE, ~(u64)0);
 143
 144         val = fire_read(pbm->pbm_regs + FIRE_TLU_CTRL);
 145         val |= (FIRE_TLU_CTRL_TIM |
 146                 FIRE_TLU_CTRL_QDET |
 147                 FIRE_TLU_CTRL_CFG);
 148         fire_write(pbm->pbm_regs + FIRE_TLU_CTRL, val);
 149         fire_write(pbm->pbm_regs + FIRE_TLU_DEV_CTRL, 0);
 150         fire_write(pbm->pbm_regs + FIRE_TLU_LINK_CTRL,
 151                    FIRE_TLU_LINK_CTRL_CLK);
 152
 153         fire_write(pbm->pbm_regs + FIRE_LPU_RESET, 0);
 154         fire_write(pbm->pbm_regs + FIRE_LPU_LLCFG,
 155                    FIRE_LPU_LLCFG_VC0);
 156         fire_write(pbm->pbm_regs + FIRE_LPU_FCTRL_UCTRL,
 157                    (FIRE_LPU_FCTRL_UCTRL_N |
 158                     FIRE_LPU_FCTRL_UCTRL_P));
 159         fire_write(pbm->pbm_regs + FIRE_LPU_TXL_FIFOP,
 160                    ((0xffff << 16) | (0x0000 << 0)));
 161         fire_write(pbm->pbm_regs + FIRE_LPU_LTSSM_CFG2, 3000000);
 162         fire_write(pbm->pbm_regs + FIRE_LPU_LTSSM_CFG3, 500000);
 163         fire_write(pbm->pbm_regs + FIRE_LPU_LTSSM_CFG4,
 164                    (2 << 16) | (140 << 8));
 165         fire_write(pbm->pbm_regs + FIRE_LPU_LTSSM_CFG5, 0);
 166
 167         fire_write(pbm->pbm_regs + FIRE_DMC_IENAB, ~(u64)0);
 168         fire_write(pbm->pbm_regs + FIRE_DMC_DBG_SEL_A, 0);
 169         fire_write(pbm->pbm_regs + FIRE_DMC_DBG_SEL_B, 0);
 170
 171         fire_write(pbm->pbm_regs + FIRE_PEC_IENAB, ~(u64)0);
 172 }
 173
 174 static int pci_fire_pbm_init(struct pci_controller_info *p,
 175                              struct device_node *dp, u32 portid)
 176 {
 177         const struct linux_prom64_registers *regs;
 178         struct pci_pbm_info *pbm;
 179
 180         if ((portid & 1) == 0)
 181                 pbm = &p->pbm_A;
 182         else
 183                 pbm = &p->pbm_B;
 184
 185         pbm->next = pci_pbm_root;
 186         pci_pbm_root = pbm;
 187
 188         pbm->scan_bus = pci_fire_scan_bus;
 189         pbm->pci_ops = &sun4u_pci_ops;
 190         pbm->config_space_reg_bits = 12;
 191
 192         pbm->index = pci_num_pbms++;
 193
 194         pbm->portid = portid;
 195         pbm->parent = p;
 196         pbm->prom_node = dp;
 197         pbm->name = dp->full_name;
 198
 199         regs = of_get_property(dp, "reg", NULL);
 200         pbm->pbm_regs = regs[0].phys_addr;
 201         pbm->controller_regs = regs[1].phys_addr - 0x410000UL;
 202
 203         printk("%s: SUN4U PCIE Bus Module\n", pbm->name);
 204
 205         pci_determine_mem_io_space(pbm);
 206
 207         pci_get_pbm_props(pbm);
 208
 209         pci_fire_hw_init(pbm);
 210
 211         return pci_fire_pbm_iommu_init(pbm);
 212 }
 213
 214 static inline int portid_compare(u32 x, u32 y)
 215 {
 216         if (x == (y ^ 1))
 217                 return 1;
 218         return 0;
 219 }
 220
 221 void fire_pci_init(struct device_node *dp, const char *model_name)
 222 {
 223         struct pci_controller_info *p;
 224         u32 portid = of_getintprop_default(dp, "portid", 0xff);
 225         struct iommu *iommu;
 226         struct pci_pbm_info *pbm;
 227
 228         for (pbm = pci_pbm_root; pbm; pbm = pbm->next) {
 229                 if (portid_compare(pbm->portid, portid)) {
 230                         if (pci_fire_pbm_init(pbm->parent, dp, portid))
 231                                 goto fatal_memory_error;
 232                         return;
 233                 }
 234         }
 235
 236         p = kzalloc(sizeof(struct pci_controller_info), GFP_ATOMIC);
 237         if (!p)
 238                 goto fatal_memory_error;
 239
 240         iommu = kzalloc(sizeof(struct iommu), GFP_ATOMIC);
 241         if (!iommu)
 242                 goto fatal_memory_error;
 243
 244         p->pbm_A.iommu = iommu;
 245
 246         iommu = kzalloc(sizeof(struct iommu), GFP_ATOMIC);
 247         if (!iommu)
 248                 goto fatal_memory_error;
 249
 250         p->pbm_B.iommu = iommu;
 251
 252         /* XXX MSI support XXX */
 253
 254         /* Like PSYCHO and SCHIZO we have a 2GB aligned area
 255          * for memory space.
 256          */
 257         pci_memspace_mask = 0x7fffffffUL;
 258
 259         if (pci_fire_pbm_init(p, dp, portid))
 260                 goto fatal_memory_error;
 261
 262         return;
 263
 264 fatal_memory_error:
 265         prom_printf("PCI_FIRE: Fatal memory allocation error.\n");
 266         prom_halt();
 267 }