2 * arch/ppc64/kernel/rtas_pci.c
4 * Copyright (C) 2001 Dave Engebretsen, IBM Corporation
5 * Copyright (C) 2003 Anton Blanchard <anton@au.ibm.com>, IBM
7 * RTAS specific routines for PCI.
9 * Based on code from pci.c, chrp_pci.c and pSeries_pci.c
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
26 #include <linux/kernel.h>
27 #include <linux/threads.h>
28 #include <linux/pci.h>
29 #include <linux/string.h>
30 #include <linux/init.h>
31 #include <linux/bootmem.h>
34 #include <asm/pgtable.h>
37 #include <asm/machdep.h>
38 #include <asm/pci-bridge.h>
39 #include <asm/iommu.h>
42 #include <asm/ppc-pci.h>
45 static int read_pci_config
;
46 static int write_pci_config
;
47 static int ibm_read_pci_config
;
48 static int ibm_write_pci_config
;
50 static int config_access_valid(struct pci_dn
*dn
, int where
)
54 if (where
< 4096 && dn
->pci_ext_config_space
)
60 static int of_device_available(struct device_node
* dn
)
64 status
= get_property(dn
, "status", NULL
);
69 if (!strcmp(status
, "okay"))
75 static int rtas_read_config(struct device_node
*dn
, int where
, int size
, u32
*val
)
78 unsigned long buid
, addr
;
83 return PCIBIOS_DEVICE_NOT_FOUND
;
85 if (!config_access_valid(pdn
, where
))
86 return PCIBIOS_BAD_REGISTER_NUMBER
;
88 addr
= ((where
& 0xf00) << 20) | (pdn
->busno
<< 16) |
89 (pdn
->devfn
<< 8) | (where
& 0xff);
90 buid
= pdn
->phb
->buid
;
92 ret
= rtas_call(ibm_read_pci_config
, 4, 2, &returnval
,
93 addr
, buid
>> 32, buid
& 0xffffffff, size
);
95 ret
= rtas_call(read_pci_config
, 2, 2, &returnval
, addr
, size
);
100 return PCIBIOS_DEVICE_NOT_FOUND
;
102 if (returnval
== EEH_IO_ERROR_VALUE(size
) &&
103 eeh_dn_check_failure (dn
, NULL
))
104 return PCIBIOS_DEVICE_NOT_FOUND
;
106 return PCIBIOS_SUCCESSFUL
;
109 static int rtas_pci_read_config(struct pci_bus
*bus
,
111 int where
, int size
, u32
*val
)
113 struct device_node
*busdn
, *dn
;
116 busdn
= pci_device_to_OF_node(bus
->self
);
118 busdn
= bus
->sysdata
; /* must be a phb */
120 /* Search only direct children of the bus */
121 for (dn
= busdn
->child
; dn
; dn
= dn
->sibling
)
122 if (dn
->data
&& PCI_DN(dn
)->devfn
== devfn
123 && of_device_available(dn
))
124 return rtas_read_config(dn
, where
, size
, val
);
126 return PCIBIOS_DEVICE_NOT_FOUND
;
129 int rtas_write_config(struct device_node
*dn
, int where
, int size
, u32 val
)
131 unsigned long buid
, addr
;
135 if (!dn
|| !dn
->data
)
136 return PCIBIOS_DEVICE_NOT_FOUND
;
138 if (!config_access_valid(pdn
, where
))
139 return PCIBIOS_BAD_REGISTER_NUMBER
;
141 addr
= ((where
& 0xf00) << 20) | (pdn
->busno
<< 16) |
142 (pdn
->devfn
<< 8) | (where
& 0xff);
143 buid
= pdn
->phb
->buid
;
145 ret
= rtas_call(ibm_write_pci_config
, 5, 1, NULL
, addr
, buid
>> 32, buid
& 0xffffffff, size
, (ulong
) val
);
147 ret
= rtas_call(write_pci_config
, 3, 1, NULL
, addr
, size
, (ulong
)val
);
151 return PCIBIOS_DEVICE_NOT_FOUND
;
153 return PCIBIOS_SUCCESSFUL
;
156 static int rtas_pci_write_config(struct pci_bus
*bus
,
158 int where
, int size
, u32 val
)
160 struct device_node
*busdn
, *dn
;
163 busdn
= pci_device_to_OF_node(bus
->self
);
165 busdn
= bus
->sysdata
; /* must be a phb */
167 /* Search only direct children of the bus */
168 for (dn
= busdn
->child
; dn
; dn
= dn
->sibling
)
169 if (dn
->data
&& PCI_DN(dn
)->devfn
== devfn
170 && of_device_available(dn
))
171 return rtas_write_config(dn
, where
, size
, val
);
172 return PCIBIOS_DEVICE_NOT_FOUND
;
175 struct pci_ops rtas_pci_ops
= {
176 rtas_pci_read_config
,
177 rtas_pci_write_config
180 int is_python(struct device_node
*dev
)
182 char *model
= (char *)get_property(dev
, "model", NULL
);
184 if (model
&& strstr(model
, "Python"))
190 static int get_phb_reg_prop(struct device_node
*dev
,
191 unsigned int addr_size_words
,
192 struct reg_property64
*reg
)
194 unsigned int *ui_ptr
= NULL
, len
;
196 /* Found a PHB, now figure out where his registers are mapped. */
197 ui_ptr
= (unsigned int *)get_property(dev
, "reg", &len
);
201 if (addr_size_words
== 1) {
202 reg
->address
= ((struct reg_property32
*)ui_ptr
)->address
;
203 reg
->size
= ((struct reg_property32
*)ui_ptr
)->size
;
205 *reg
= *((struct reg_property64
*)ui_ptr
);
211 static void python_countermeasures(struct device_node
*dev
,
212 unsigned int addr_size_words
)
214 struct reg_property64 reg_struct
;
215 void __iomem
*chip_regs
;
218 if (get_phb_reg_prop(dev
, addr_size_words
, ®_struct
))
221 /* Python's register file is 1 MB in size. */
222 chip_regs
= ioremap(reg_struct
.address
& ~(0xfffffUL
), 0x100000);
225 * Firmware doesn't always clear this bit which is critical
226 * for good performance - Anton
229 #define PRG_CL_RESET_VALID 0x00010000
231 val
= in_be32(chip_regs
+ 0xf6030);
232 if (val
& PRG_CL_RESET_VALID
) {
233 printk(KERN_INFO
"Python workaround: ");
234 val
&= ~PRG_CL_RESET_VALID
;
235 out_be32(chip_regs
+ 0xf6030, val
);
237 * We must read it back for changes to
240 val
= in_be32(chip_regs
+ 0xf6030);
241 printk("reg0: %x\n", val
);
247 void __init
init_pci_config_tokens (void)
249 read_pci_config
= rtas_token("read-pci-config");
250 write_pci_config
= rtas_token("write-pci-config");
251 ibm_read_pci_config
= rtas_token("ibm,read-pci-config");
252 ibm_write_pci_config
= rtas_token("ibm,write-pci-config");
255 unsigned long __devinit
get_phb_buid (struct device_node
*phb
)
258 unsigned int *buid_vals
;
262 if (ibm_read_pci_config
== -1) return 0;
264 /* PHB's will always be children of the root node,
265 * or so it is promised by the current firmware. */
266 if (phb
->parent
== NULL
)
268 if (phb
->parent
->parent
)
271 buid_vals
= (unsigned int *) get_property(phb
, "reg", &len
);
272 if (buid_vals
== NULL
)
275 addr_cells
= prom_n_addr_cells(phb
);
276 if (addr_cells
== 1) {
277 buid
= (unsigned long) buid_vals
[0];
279 buid
= (((unsigned long)buid_vals
[0]) << 32UL) |
280 (((unsigned long)buid_vals
[1]) & 0xffffffff);
285 static int phb_set_bus_ranges(struct device_node
*dev
,
286 struct pci_controller
*phb
)
291 bus_range
= (int *) get_property(dev
, "bus-range", &len
);
292 if (bus_range
== NULL
|| len
< 2 * sizeof(int)) {
296 phb
->first_busno
= bus_range
[0];
297 phb
->last_busno
= bus_range
[1];
302 static int __devinit
setup_phb(struct device_node
*dev
,
303 struct pci_controller
*phb
,
304 unsigned int addr_size_words
)
306 pci_setup_pci_controller(phb
);
309 python_countermeasures(dev
, addr_size_words
);
311 if (phb_set_bus_ranges(dev
, phb
))
314 phb
->arch_data
= dev
;
315 phb
->ops
= &rtas_pci_ops
;
316 phb
->buid
= get_phb_buid(dev
);
321 static void __devinit
add_linux_pci_domain(struct device_node
*dev
,
322 struct pci_controller
*phb
,
323 struct property
*of_prop
)
325 memset(of_prop
, 0, sizeof(struct property
));
326 of_prop
->name
= "linux,pci-domain";
327 of_prop
->length
= sizeof(phb
->global_number
);
328 of_prop
->value
= (unsigned char *)&of_prop
[1];
329 memcpy(of_prop
->value
, &phb
->global_number
, sizeof(phb
->global_number
));
330 prom_add_property(dev
, of_prop
);
333 static struct pci_controller
* __init
alloc_phb(struct device_node
*dev
,
334 unsigned int addr_size_words
)
336 struct pci_controller
*phb
;
337 struct property
*of_prop
;
339 phb
= alloc_bootmem(sizeof(struct pci_controller
));
343 of_prop
= alloc_bootmem(sizeof(struct property
) +
344 sizeof(phb
->global_number
));
348 if (setup_phb(dev
, phb
, addr_size_words
))
351 add_linux_pci_domain(dev
, phb
, of_prop
);
356 static struct pci_controller
* __devinit
alloc_phb_dynamic(struct device_node
*dev
, unsigned int addr_size_words
)
358 struct pci_controller
*phb
;
360 phb
= (struct pci_controller
*)kmalloc(sizeof(struct pci_controller
),
365 if (setup_phb(dev
, phb
, addr_size_words
))
370 /* TODO: linux,pci-domain? */
375 unsigned long __init
find_and_init_phbs(void)
377 struct device_node
*node
;
378 struct pci_controller
*phb
;
379 unsigned int root_size_cells
= 0;
381 unsigned int *opprop
= NULL
;
382 struct device_node
*root
= of_find_node_by_path("/");
384 if (ppc64_interrupt_controller
== IC_OPEN_PIC
) {
385 opprop
= (unsigned int *)get_property(root
,
386 "platform-open-pic", NULL
);
389 root_size_cells
= prom_n_size_cells(root
);
393 for (node
= of_get_next_child(root
, NULL
);
395 node
= of_get_next_child(root
, node
)) {
396 if (node
->type
== NULL
|| strcmp(node
->type
, "pci") != 0)
399 phb
= alloc_phb(node
, root_size_cells
);
403 pci_process_bridge_OF_ranges(phb
, node
, 0);
404 pci_setup_phb_io(phb
, index
== 0);
405 #ifdef CONFIG_PPC_PSERIES
406 if (ppc64_interrupt_controller
== IC_OPEN_PIC
&& pSeries_mpic
) {
407 int addr
= root_size_cells
* (index
+ 2) - 1;
408 mpic_assign_isu(pSeries_mpic
, index
, opprop
[addr
]);
418 * pci_probe_only and pci_assign_all_buses can be set via properties
424 prop
= (int *)get_property(of_chosen
, "linux,pci-probe-only",
427 pci_probe_only
= *prop
;
429 prop
= (int *)get_property(of_chosen
,
430 "linux,pci-assign-all-buses", NULL
);
432 pci_assign_all_buses
= *prop
;
438 struct pci_controller
* __devinit
init_phb_dynamic(struct device_node
*dn
)
440 struct device_node
*root
= of_find_node_by_path("/");
441 unsigned int root_size_cells
= 0;
442 struct pci_controller
*phb
;
445 root_size_cells
= prom_n_size_cells(root
);
447 primary
= list_empty(&hose_list
);
448 phb
= alloc_phb_dynamic(dn
, root_size_cells
);
452 pci_process_bridge_OF_ranges(phb
, dn
, primary
);
454 pci_setup_phb_io_dynamic(phb
, primary
);
457 pci_devs_phb_init_dynamic(phb
);
462 EXPORT_SYMBOL(init_phb_dynamic
);
464 /* RPA-specific bits for removing PHBs */
465 int pcibios_remove_root_bus(struct pci_controller
*phb
)
467 struct pci_bus
*b
= phb
->bus
;
468 struct resource
*res
;
471 res
= b
->resource
[0];
473 printk(KERN_ERR
"%s: no IO resource for PHB %s\n", __FUNCTION__
,
478 rc
= unmap_bus_range(b
);
480 printk(KERN_ERR
"%s: failed to unmap IO on bus %s\n",
481 __FUNCTION__
, b
->name
);
485 if (release_resource(res
)) {
486 printk(KERN_ERR
"%s: failed to release IO on bus %s\n",
487 __FUNCTION__
, b
->name
);
491 for (i
= 1; i
< 3; ++i
) {
492 res
= b
->resource
[i
];
493 if (!res
->flags
&& i
== 0) {
494 printk(KERN_ERR
"%s: no MEM resource for PHB %s\n",
495 __FUNCTION__
, b
->name
);
498 if (res
->flags
&& release_resource(res
)) {
500 "%s: failed to release IO %d on bus %s\n",
501 __FUNCTION__
, i
, b
->name
);
506 list_del(&phb
->list_node
);
512 EXPORT_SYMBOL(pcibios_remove_root_bus
);