746ce5e51208bcb43cc1be1ba1a57844cbbeb0b5
[linux-2.6.git] / arch / powerpc / platforms / powernv / pci.c
1 /*
2  * Support PCI/PCIe on PowerNV platforms
3  *
4  * Currently supports only P5IOC2
5  *
6  * Copyright 2011 Benjamin Herrenschmidt, IBM Corp.
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License
10  * as published by the Free Software Foundation; either version
11  * 2 of the License, or (at your option) any later version.
12  */
13
14 #include <linux/kernel.h>
15 #include <linux/pci.h>
16 #include <linux/delay.h>
17 #include <linux/string.h>
18 #include <linux/init.h>
19 #include <linux/bootmem.h>
20 #include <linux/irq.h>
21 #include <linux/io.h>
22
23 #include <asm/sections.h>
24 #include <asm/io.h>
25 #include <asm/prom.h>
26 #include <asm/pci-bridge.h>
27 #include <asm/machdep.h>
28 #include <asm/ppc-pci.h>
29 #include <asm/opal.h>
30 #include <asm/iommu.h>
31 #include <asm/tce.h>
32 #include <asm/abs_addr.h>
33
34 #include "powernv.h"
35 #include "pci.h"
36
37
38 #define cfg_dbg(fmt...) do { } while(0)
39 //#define cfg_dbg(fmt...)       printk(fmt)
40
41
42 static void pnv_pci_config_check_eeh(struct pnv_phb *phb, struct pci_bus *bus,
43                                      u32 bdfn)
44 {
45         s64     rc;
46         u8      fstate;
47         u16     pcierr;
48         u32     pe_no;
49
50         /* Get PE# if we support IODA */
51         pe_no = phb->bdfn_to_pe ? phb->bdfn_to_pe(phb, bus, bdfn & 0xff) : 0;
52
53         /* Read freeze status */
54         rc = opal_pci_eeh_freeze_status(phb->opal_id, pe_no, &fstate, &pcierr,
55                                         NULL);
56         if (rc) {
57                 pr_warning("PCI %d: Failed to read EEH status for PE#%d,"
58                            " err %lld\n", phb->hose->global_number, pe_no, rc);
59                 return;
60         }
61         cfg_dbg(" -> EEH check, bdfn=%04x PE%d fstate=%x\n",
62                 bdfn, pe_no, fstate);
63         if (fstate != 0) {
64                 rc = opal_pci_eeh_freeze_clear(phb->opal_id, pe_no,
65                                               OPAL_EEH_ACTION_CLEAR_FREEZE_ALL);
66                 if (rc) {
67                         pr_warning("PCI %d: Failed to clear EEH freeze state"
68                                    " for PE#%d, err %lld\n",
69                                    phb->hose->global_number, pe_no, rc);
70                 }
71         }
72 }
73
74 static int pnv_pci_read_config(struct pci_bus *bus,
75                                unsigned int devfn,
76                                int where, int size, u32 *val)
77 {
78         struct pci_controller *hose = pci_bus_to_host(bus);
79         struct pnv_phb *phb = hose->private_data;
80         u32 bdfn = (((uint64_t)bus->number) << 8) | devfn;
81         s64 rc;
82
83         if (hose == NULL)
84                 return PCIBIOS_DEVICE_NOT_FOUND;
85
86         switch (size) {
87         case 1: {
88                 u8 v8;
89                 rc = opal_pci_config_read_byte(phb->opal_id, bdfn, where, &v8);
90                 *val = (rc == OPAL_SUCCESS) ? v8 : 0xff;
91                 break;
92         }
93         case 2: {
94                 u16 v16;
95                 rc = opal_pci_config_read_half_word(phb->opal_id, bdfn, where,
96                                                    &v16);
97                 *val = (rc == OPAL_SUCCESS) ? v16 : 0xffff;
98                 break;
99         }
100         case 4: {
101                 u32 v32;
102                 rc = opal_pci_config_read_word(phb->opal_id, bdfn, where, &v32);
103                 *val = (rc == OPAL_SUCCESS) ? v32 : 0xffffffff;
104                 break;
105         }
106         default:
107                 return PCIBIOS_FUNC_NOT_SUPPORTED;
108         }
109         cfg_dbg("pnv_pci_read_config bus: %x devfn: %x +%x/%x -> %08x\n",
110                 bus->number, devfn, where, size, *val);
111
112         /* Check if the PHB got frozen due to an error (no response) */
113         pnv_pci_config_check_eeh(phb, bus, bdfn);
114
115         return PCIBIOS_SUCCESSFUL;
116 }
117
118 static int pnv_pci_write_config(struct pci_bus *bus,
119                                 unsigned int devfn,
120                                 int where, int size, u32 val)
121 {
122         struct pci_controller *hose = pci_bus_to_host(bus);
123         struct pnv_phb *phb = hose->private_data;
124         u32 bdfn = (((uint64_t)bus->number) << 8) | devfn;
125
126         if (hose == NULL)
127                 return PCIBIOS_DEVICE_NOT_FOUND;
128
129         cfg_dbg("pnv_pci_write_config bus: %x devfn: %x +%x/%x -> %08x\n",
130                 bus->number, devfn, where, size, val);
131         switch (size) {
132         case 1:
133                 opal_pci_config_write_byte(phb->opal_id, bdfn, where, val);
134                 break;
135         case 2:
136                 opal_pci_config_write_half_word(phb->opal_id, bdfn, where, val);
137                 break;
138         case 4:
139                 opal_pci_config_write_word(phb->opal_id, bdfn, where, val);
140                 break;
141         default:
142                 return PCIBIOS_FUNC_NOT_SUPPORTED;
143         }
144         /* Check if the PHB got frozen due to an error (no response) */
145         pnv_pci_config_check_eeh(phb, bus, bdfn);
146
147         return PCIBIOS_SUCCESSFUL;
148 }
149
150 struct pci_ops pnv_pci_ops = {
151         .read = pnv_pci_read_config,
152         .write = pnv_pci_write_config,
153 };
154
155 static int pnv_tce_build(struct iommu_table *tbl, long index, long npages,
156                          unsigned long uaddr, enum dma_data_direction direction,
157                          struct dma_attrs *attrs)
158 {
159         u64 proto_tce;
160         u64 *tcep;
161         u64 rpn;
162
163         proto_tce = TCE_PCI_READ; // Read allowed
164
165         if (direction != DMA_TO_DEVICE)
166                 proto_tce |= TCE_PCI_WRITE;
167
168         tcep = ((u64 *)tbl->it_base) + index;
169
170         while (npages--) {
171                 /* can't move this out since we might cross LMB boundary */
172                 rpn = (virt_to_abs(uaddr)) >> TCE_SHIFT;
173                 *tcep = proto_tce | (rpn & TCE_RPN_MASK) << TCE_RPN_SHIFT;
174
175                 uaddr += TCE_PAGE_SIZE;
176                 tcep++;
177         }
178         return 0;
179 }
180
181 static void pnv_tce_free(struct iommu_table *tbl, long index, long npages)
182 {
183         u64 *tcep = ((u64 *)tbl->it_base) + index;
184
185         while (npages--)
186                 *(tcep++) = 0;
187 }
188
189 void pnv_pci_setup_iommu_table(struct iommu_table *tbl,
190                                void *tce_mem, u64 tce_size,
191                                u64 dma_offset)
192 {
193         tbl->it_blocksize = 16;
194         tbl->it_base = (unsigned long)tce_mem;
195         tbl->it_offset = dma_offset >> IOMMU_PAGE_SHIFT;
196         tbl->it_index = 0;
197         tbl->it_size = tce_size >> 3;
198         tbl->it_busno = 0;
199         tbl->it_type = TCE_PCI;
200 }
201
202 static struct iommu_table * __devinit
203 pnv_pci_setup_bml_iommu(struct pci_controller *hose)
204 {
205         struct iommu_table *tbl;
206         const __be64 *basep;
207         const __be32 *sizep;
208
209         basep = of_get_property(hose->dn, "linux,tce-base", NULL);
210         sizep = of_get_property(hose->dn, "linux,tce-size", NULL);
211         if (basep == NULL || sizep == NULL) {
212                 pr_err("PCI: %s has missing tce entries !\n", hose->dn->full_name);
213                 return NULL;
214         }
215         tbl = kzalloc_node(sizeof(struct iommu_table), GFP_KERNEL, hose->node);
216         if (WARN_ON(!tbl))
217                 return NULL;
218         pnv_pci_setup_iommu_table(tbl, __va(be64_to_cpup(basep)),
219                                   be32_to_cpup(sizep), 0);
220         iommu_init_table(tbl, hose->node);
221         return tbl;
222 }
223
224 static void __devinit pnv_pci_dma_fallback_setup(struct pci_controller *hose,
225                                                  struct pci_dev *pdev)
226 {
227         struct device_node *np = pci_bus_to_OF_node(hose->bus);
228         struct pci_dn *pdn;
229
230         if (np == NULL)
231                 return;
232         pdn = PCI_DN(np);
233         if (!pdn->iommu_table)
234                 pdn->iommu_table = pnv_pci_setup_bml_iommu(hose);
235         if (!pdn->iommu_table)
236                 return;
237         set_iommu_table_base(&pdev->dev, pdn->iommu_table);
238 }
239
240 static void __devinit pnv_pci_dma_dev_setup(struct pci_dev *pdev)
241 {
242         struct pci_controller *hose = pci_bus_to_host(pdev->bus);
243         struct pnv_phb *phb = hose->private_data;
244
245         /* If we have no phb structure, try to setup a fallback based on
246          * the device-tree (RTAS PCI for example)
247          */
248         if (phb && phb->dma_dev_setup)
249                 phb->dma_dev_setup(phb, pdev);
250         else
251                 pnv_pci_dma_fallback_setup(hose, pdev);
252 }
253
254 void __init pnv_pci_init(void)
255 {
256         struct device_node *np;
257
258         pci_set_flags(PCI_CAN_SKIP_ISA_ALIGN);
259
260         /* We do not want to just probe */
261         pci_probe_only = 0;
262
263         /* OPAL absent, try POPAL first then RTAS detection of PHBs */
264         if (!firmware_has_feature(FW_FEATURE_OPAL)) {
265 #ifdef CONFIG_PPC_POWERNV_RTAS
266                 init_pci_config_tokens();
267                 find_and_init_phbs();
268 #endif /* CONFIG_PPC_POWERNV_RTAS */
269         } else {
270                 /* OPAL is here, do our normal stuff */
271
272                 /* Look for p5ioc2 IO-Hubs */
273                 for_each_compatible_node(np, NULL, "ibm,p5ioc2")
274                         pnv_pci_init_p5ioc2_hub(np);
275         }
276
277         /* Setup the linkage between OF nodes and PHBs */
278         pci_devs_phb_init();
279
280         /* Configure IOMMU DMA hooks */
281         ppc_md.pci_dma_dev_setup = pnv_pci_dma_dev_setup;
282         ppc_md.tce_build = pnv_tce_build;
283         ppc_md.tce_free = pnv_tce_free;
284         set_pci_dma_ops(&dma_iommu_ops);
285
286 }