Commit | Line | Data |
---|---|---|
c5a3c2e5 | 1 | /* |
c5a3c2e5 AB |
2 | * Copyright (C) 2001 Dave Engebretsen, IBM Corporation |
3 | * Copyright (C) 2003 Anton Blanchard <anton@au.ibm.com>, IBM | |
4 | * | |
5 | * RTAS specific routines for PCI. | |
ae65a391 | 6 | * |
c5a3c2e5 AB |
7 | * Based on code from pci.c, chrp_pci.c and pSeries_pci.c |
8 | * | |
9 | * This program is free software; you can redistribute it and/or modify | |
10 | * it under the terms of the GNU General Public License as published by | |
11 | * the Free Software Foundation; either version 2 of the License, or | |
12 | * (at your option) any later version. | |
ae65a391 | 13 | * |
c5a3c2e5 AB |
14 | * This program is distributed in the hope that it will be useful, |
15 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
16 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
17 | * GNU General Public License for more details. | |
ae65a391 | 18 | * |
c5a3c2e5 AB |
19 | * You should have received a copy of the GNU General Public License |
20 | * along with this program; if not, write to the Free Software | |
21 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
22 | */ | |
23 | ||
24 | #include <linux/kernel.h> | |
25 | #include <linux/threads.h> | |
26 | #include <linux/pci.h> | |
27 | #include <linux/string.h> | |
28 | #include <linux/init.h> | |
29 | #include <linux/bootmem.h> | |
30 | ||
31 | #include <asm/io.h> | |
32 | #include <asm/pgtable.h> | |
33 | #include <asm/irq.h> | |
34 | #include <asm/prom.h> | |
35 | #include <asm/machdep.h> | |
36 | #include <asm/pci-bridge.h> | |
37 | #include <asm/iommu.h> | |
38 | #include <asm/rtas.h> | |
bbeb3f4c | 39 | #include <asm/mpic.h> |
d387899f | 40 | #include <asm/ppc-pci.h> |
c5a3c2e5 AB |
41 | |
42 | /* RTAS tokens */ | |
43 | static int read_pci_config; | |
44 | static int write_pci_config; | |
45 | static int ibm_read_pci_config; | |
46 | static int ibm_write_pci_config; | |
47 | ||
ae65a391 | 48 | static inline int config_access_valid(struct pci_dn *dn, int where) |
c5a3c2e5 AB |
49 | { |
50 | if (where < 256) | |
51 | return 1; | |
52 | if (where < 4096 && dn->pci_ext_config_space) | |
53 | return 1; | |
54 | ||
55 | return 0; | |
56 | } | |
57 | ||
293da76b JM |
58 | static int of_device_available(struct device_node * dn) |
59 | { | |
a7f67bdf | 60 | const char *status; |
293da76b JM |
61 | |
62 | status = get_property(dn, "status", NULL); | |
63 | ||
64 | if (!status) | |
65 | return 1; | |
66 | ||
67 | if (!strcmp(status, "okay")) | |
68 | return 1; | |
69 | ||
70 | return 0; | |
71 | } | |
72 | ||
7684b40c | 73 | int rtas_read_config(struct pci_dn *pdn, int where, int size, u32 *val) |
c5a3c2e5 AB |
74 | { |
75 | int returnval = -1; | |
76 | unsigned long buid, addr; | |
77 | int ret; | |
78 | ||
ae65a391 | 79 | if (!pdn) |
c5a3c2e5 | 80 | return PCIBIOS_DEVICE_NOT_FOUND; |
1635317f | 81 | if (!config_access_valid(pdn, where)) |
c5a3c2e5 AB |
82 | return PCIBIOS_BAD_REGISTER_NUMBER; |
83 | ||
6f3d5d3c | 84 | addr = rtas_config_addr(pdn->busno, pdn->devfn, where); |
1635317f | 85 | buid = pdn->phb->buid; |
c5a3c2e5 AB |
86 | if (buid) { |
87 | ret = rtas_call(ibm_read_pci_config, 4, 2, &returnval, | |
ae65a391 | 88 | addr, BUID_HI(buid), BUID_LO(buid), size); |
c5a3c2e5 AB |
89 | } else { |
90 | ret = rtas_call(read_pci_config, 2, 2, &returnval, addr, size); | |
91 | } | |
92 | *val = returnval; | |
93 | ||
94 | if (ret) | |
95 | return PCIBIOS_DEVICE_NOT_FOUND; | |
96 | ||
1635317f | 97 | if (returnval == EEH_IO_ERROR_VALUE(size) && |
ae65a391 | 98 | eeh_dn_check_failure (pdn->node, NULL)) |
c5a3c2e5 AB |
99 | return PCIBIOS_DEVICE_NOT_FOUND; |
100 | ||
101 | return PCIBIOS_SUCCESSFUL; | |
102 | } | |
103 | ||
104 | static int rtas_pci_read_config(struct pci_bus *bus, | |
105 | unsigned int devfn, | |
106 | int where, int size, u32 *val) | |
107 | { | |
108 | struct device_node *busdn, *dn; | |
109 | ||
110 | if (bus->self) | |
111 | busdn = pci_device_to_OF_node(bus->self); | |
112 | else | |
113 | busdn = bus->sysdata; /* must be a phb */ | |
114 | ||
115 | /* Search only direct children of the bus */ | |
ae65a391 | 116 | for (dn = busdn->child; dn; dn = dn->sibling) { |
117 | struct pci_dn *pdn = PCI_DN(dn); | |
118 | if (pdn && pdn->devfn == devfn | |
1635317f | 119 | && of_device_available(dn)) |
ae65a391 | 120 | return rtas_read_config(pdn, where, size, val); |
121 | } | |
1635317f | 122 | |
c5a3c2e5 AB |
123 | return PCIBIOS_DEVICE_NOT_FOUND; |
124 | } | |
125 | ||
ae65a391 | 126 | int rtas_write_config(struct pci_dn *pdn, int where, int size, u32 val) |
c5a3c2e5 AB |
127 | { |
128 | unsigned long buid, addr; | |
129 | int ret; | |
130 | ||
ae65a391 | 131 | if (!pdn) |
c5a3c2e5 | 132 | return PCIBIOS_DEVICE_NOT_FOUND; |
1635317f | 133 | if (!config_access_valid(pdn, where)) |
c5a3c2e5 AB |
134 | return PCIBIOS_BAD_REGISTER_NUMBER; |
135 | ||
6f3d5d3c | 136 | addr = rtas_config_addr(pdn->busno, pdn->devfn, where); |
1635317f | 137 | buid = pdn->phb->buid; |
c5a3c2e5 | 138 | if (buid) { |
ae65a391 | 139 | ret = rtas_call(ibm_write_pci_config, 5, 1, NULL, addr, |
140 | BUID_HI(buid), BUID_LO(buid), size, (ulong) val); | |
c5a3c2e5 AB |
141 | } else { |
142 | ret = rtas_call(write_pci_config, 3, 1, NULL, addr, size, (ulong)val); | |
143 | } | |
144 | ||
145 | if (ret) | |
146 | return PCIBIOS_DEVICE_NOT_FOUND; | |
147 | ||
148 | return PCIBIOS_SUCCESSFUL; | |
149 | } | |
150 | ||
151 | static int rtas_pci_write_config(struct pci_bus *bus, | |
152 | unsigned int devfn, | |
153 | int where, int size, u32 val) | |
154 | { | |
155 | struct device_node *busdn, *dn; | |
156 | ||
157 | if (bus->self) | |
158 | busdn = pci_device_to_OF_node(bus->self); | |
159 | else | |
160 | busdn = bus->sysdata; /* must be a phb */ | |
161 | ||
162 | /* Search only direct children of the bus */ | |
ae65a391 | 163 | for (dn = busdn->child; dn; dn = dn->sibling) { |
164 | struct pci_dn *pdn = PCI_DN(dn); | |
165 | if (pdn && pdn->devfn == devfn | |
1635317f | 166 | && of_device_available(dn)) |
ae65a391 | 167 | return rtas_write_config(pdn, where, size, val); |
168 | } | |
c5a3c2e5 AB |
169 | return PCIBIOS_DEVICE_NOT_FOUND; |
170 | } | |
171 | ||
172 | struct pci_ops rtas_pci_ops = { | |
173 | rtas_pci_read_config, | |
174 | rtas_pci_write_config | |
175 | }; | |
176 | ||
177 | int is_python(struct device_node *dev) | |
178 | { | |
a7f67bdf | 179 | const char *model = get_property(dev, "model", NULL); |
c5a3c2e5 AB |
180 | |
181 | if (model && strstr(model, "Python")) | |
182 | return 1; | |
183 | ||
184 | return 0; | |
185 | } | |
186 | ||
cc5d0189 | 187 | static void python_countermeasures(struct device_node *dev) |
c5a3c2e5 | 188 | { |
cc5d0189 | 189 | struct resource registers; |
c5a3c2e5 AB |
190 | void __iomem *chip_regs; |
191 | volatile u32 val; | |
192 | ||
cc5d0189 BH |
193 | if (of_address_to_resource(dev, 0, ®isters)) { |
194 | printk(KERN_ERR "Can't get address for Python workarounds !\n"); | |
c5a3c2e5 | 195 | return; |
cc5d0189 | 196 | } |
c5a3c2e5 AB |
197 | |
198 | /* Python's register file is 1 MB in size. */ | |
cc5d0189 | 199 | chip_regs = ioremap(registers.start & ~(0xfffffUL), 0x100000); |
c5a3c2e5 | 200 | |
ae65a391 | 201 | /* |
c5a3c2e5 AB |
202 | * Firmware doesn't always clear this bit which is critical |
203 | * for good performance - Anton | |
204 | */ | |
205 | ||
206 | #define PRG_CL_RESET_VALID 0x00010000 | |
207 | ||
208 | val = in_be32(chip_regs + 0xf6030); | |
209 | if (val & PRG_CL_RESET_VALID) { | |
210 | printk(KERN_INFO "Python workaround: "); | |
211 | val &= ~PRG_CL_RESET_VALID; | |
212 | out_be32(chip_regs + 0xf6030, val); | |
213 | /* | |
214 | * We must read it back for changes to | |
215 | * take effect | |
216 | */ | |
217 | val = in_be32(chip_regs + 0xf6030); | |
218 | printk("reg0: %x\n", val); | |
219 | } | |
220 | ||
221 | iounmap(chip_regs); | |
222 | } | |
223 | ||
224 | void __init init_pci_config_tokens (void) | |
225 | { | |
226 | read_pci_config = rtas_token("read-pci-config"); | |
227 | write_pci_config = rtas_token("write-pci-config"); | |
228 | ibm_read_pci_config = rtas_token("ibm,read-pci-config"); | |
229 | ibm_write_pci_config = rtas_token("ibm,write-pci-config"); | |
230 | } | |
231 | ||
232 | unsigned long __devinit get_phb_buid (struct device_node *phb) | |
233 | { | |
234 | int addr_cells; | |
a7f67bdf | 235 | const unsigned int *buid_vals; |
c5a3c2e5 AB |
236 | unsigned int len; |
237 | unsigned long buid; | |
238 | ||
239 | if (ibm_read_pci_config == -1) return 0; | |
240 | ||
241 | /* PHB's will always be children of the root node, | |
242 | * or so it is promised by the current firmware. */ | |
243 | if (phb->parent == NULL) | |
244 | return 0; | |
245 | if (phb->parent->parent) | |
246 | return 0; | |
247 | ||
a7f67bdf | 248 | buid_vals = get_property(phb, "reg", &len); |
c5a3c2e5 AB |
249 | if (buid_vals == NULL) |
250 | return 0; | |
251 | ||
252 | addr_cells = prom_n_addr_cells(phb); | |
253 | if (addr_cells == 1) { | |
254 | buid = (unsigned long) buid_vals[0]; | |
255 | } else { | |
256 | buid = (((unsigned long)buid_vals[0]) << 32UL) | | |
257 | (((unsigned long)buid_vals[1]) & 0xffffffff); | |
258 | } | |
259 | return buid; | |
260 | } | |
261 | ||
262 | static int phb_set_bus_ranges(struct device_node *dev, | |
263 | struct pci_controller *phb) | |
264 | { | |
a7f67bdf | 265 | const int *bus_range; |
c5a3c2e5 AB |
266 | unsigned int len; |
267 | ||
a7f67bdf | 268 | bus_range = get_property(dev, "bus-range", &len); |
c5a3c2e5 AB |
269 | if (bus_range == NULL || len < 2 * sizeof(int)) { |
270 | return 1; | |
271 | } | |
ae65a391 | 272 | |
c5a3c2e5 AB |
273 | phb->first_busno = bus_range[0]; |
274 | phb->last_busno = bus_range[1]; | |
275 | ||
276 | return 0; | |
277 | } | |
278 | ||
92eb4602 | 279 | int __devinit setup_phb(struct device_node *dev, struct pci_controller *phb) |
c5a3c2e5 | 280 | { |
c5a3c2e5 | 281 | if (is_python(dev)) |
cc5d0189 | 282 | python_countermeasures(dev); |
c5a3c2e5 AB |
283 | |
284 | if (phb_set_bus_ranges(dev, phb)) | |
285 | return 1; | |
286 | ||
c5a3c2e5 AB |
287 | phb->ops = &rtas_pci_ops; |
288 | phb->buid = get_phb_buid(dev); | |
289 | ||
290 | return 0; | |
291 | } | |
292 | ||
c5a3c2e5 AB |
293 | unsigned long __init find_and_init_phbs(void) |
294 | { | |
295 | struct device_node *node; | |
296 | struct pci_controller *phb; | |
c5a3c2e5 | 297 | unsigned int index; |
c5a3c2e5 AB |
298 | struct device_node *root = of_find_node_by_path("/"); |
299 | ||
c5a3c2e5 | 300 | index = 0; |
c5a3c2e5 AB |
301 | for (node = of_get_next_child(root, NULL); |
302 | node != NULL; | |
303 | node = of_get_next_child(root, node)) { | |
bb53bb3d JM |
304 | |
305 | if (node->type == NULL || (strcmp(node->type, "pci") != 0 && | |
306 | strcmp(node->type, "pciex") != 0)) | |
c5a3c2e5 AB |
307 | continue; |
308 | ||
b5166cc2 | 309 | phb = pcibios_alloc_controller(node); |
c5a3c2e5 AB |
310 | if (!phb) |
311 | continue; | |
cc5d0189 | 312 | setup_phb(node, phb); |
f7abbc19 | 313 | pci_process_bridge_OF_ranges(phb, node, 0); |
c5a3c2e5 | 314 | pci_setup_phb_io(phb, index == 0); |
c5a3c2e5 AB |
315 | index++; |
316 | } | |
317 | ||
318 | of_node_put(root); | |
319 | pci_devs_phb_init(); | |
320 | ||
321 | /* | |
322 | * pci_probe_only and pci_assign_all_buses can be set via properties | |
323 | * in chosen. | |
324 | */ | |
325 | if (of_chosen) { | |
a7f67bdf | 326 | const int *prop; |
c5a3c2e5 | 327 | |
a7f67bdf JK |
328 | prop = get_property(of_chosen, |
329 | "linux,pci-probe-only", NULL); | |
c5a3c2e5 AB |
330 | if (prop) |
331 | pci_probe_only = *prop; | |
332 | ||
a7f67bdf JK |
333 | prop = get_property(of_chosen, |
334 | "linux,pci-assign-all-buses", NULL); | |
c5a3c2e5 AB |
335 | if (prop) |
336 | pci_assign_all_buses = *prop; | |
337 | } | |
338 | ||
339 | return 0; | |
340 | } | |
341 | ||
c5a3c2e5 AB |
342 | /* RPA-specific bits for removing PHBs */ |
343 | int pcibios_remove_root_bus(struct pci_controller *phb) | |
344 | { | |
345 | struct pci_bus *b = phb->bus; | |
346 | struct resource *res; | |
347 | int rc, i; | |
348 | ||
349 | res = b->resource[0]; | |
350 | if (!res->flags) { | |
351 | printk(KERN_ERR "%s: no IO resource for PHB %s\n", __FUNCTION__, | |
352 | b->name); | |
353 | return 1; | |
354 | } | |
355 | ||
356 | rc = unmap_bus_range(b); | |
357 | if (rc) { | |
358 | printk(KERN_ERR "%s: failed to unmap IO on bus %s\n", | |
359 | __FUNCTION__, b->name); | |
360 | return 1; | |
361 | } | |
362 | ||
363 | if (release_resource(res)) { | |
364 | printk(KERN_ERR "%s: failed to release IO on bus %s\n", | |
365 | __FUNCTION__, b->name); | |
366 | return 1; | |
367 | } | |
368 | ||
369 | for (i = 1; i < 3; ++i) { | |
370 | res = b->resource[i]; | |
371 | if (!res->flags && i == 0) { | |
372 | printk(KERN_ERR "%s: no MEM resource for PHB %s\n", | |
373 | __FUNCTION__, b->name); | |
374 | return 1; | |
375 | } | |
376 | if (res->flags && release_resource(res)) { | |
377 | printk(KERN_ERR | |
378 | "%s: failed to release IO %d on bus %s\n", | |
379 | __FUNCTION__, i, b->name); | |
380 | return 1; | |
381 | } | |
382 | } | |
383 | ||
384 | list_del(&phb->list_node); | |
b5166cc2 | 385 | pcibios_free_controller(phb); |
c5a3c2e5 AB |
386 | |
387 | return 0; | |
388 | } | |
389 | EXPORT_SYMBOL(pcibios_remove_root_bus); |