Loading...
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Support PCI IO workaround
4 *
5 * Copyright (C) 2006 Benjamin Herrenschmidt <benh@kernel.crashing.org>
6 * IBM, Corp.
7 * (C) Copyright 2007-2008 TOSHIBA CORPORATION
8 */
9#undef DEBUG
10
11#include <linux/kernel.h>
12#include <linux/sched/mm.h> /* for init_mm */
13#include <linux/pgtable.h>
14
15#include <asm/io.h>
16#include <asm/machdep.h>
17#include <asm/ppc-pci.h>
18#include <asm/io-workarounds.h>
19#include <asm/pte-walk.h>
20
21
22#define IOWA_MAX_BUS 8
23
24static struct iowa_bus iowa_busses[IOWA_MAX_BUS];
25static unsigned int iowa_bus_count;
26
27static struct iowa_bus *iowa_pci_find(unsigned long vaddr, unsigned long paddr)
28{
29 int i, j;
30 struct resource *res;
31 unsigned long vstart, vend;
32
33 for (i = 0; i < iowa_bus_count; i++) {
34 struct iowa_bus *bus = &iowa_busses[i];
35 struct pci_controller *phb = bus->phb;
36
37 if (vaddr) {
38 vstart = (unsigned long)phb->io_base_virt;
39 vend = vstart + phb->pci_io_size - 1;
40 if ((vaddr >= vstart) && (vaddr <= vend))
41 return bus;
42 }
43
44 if (paddr)
45 for (j = 0; j < 3; j++) {
46 res = &phb->mem_resources[j];
47 if (paddr >= res->start && paddr <= res->end)
48 return bus;
49 }
50 }
51
52 return NULL;
53}
54
55#ifdef CONFIG_PPC_INDIRECT_MMIO
56struct iowa_bus *iowa_mem_find_bus(const PCI_IO_ADDR addr)
57{
58 struct iowa_bus *bus;
59 int token;
60
61 token = PCI_GET_ADDR_TOKEN(addr);
62
63 if (token && token <= iowa_bus_count)
64 bus = &iowa_busses[token - 1];
65 else {
66 unsigned long vaddr, paddr;
67
68 vaddr = (unsigned long)PCI_FIX_ADDR(addr);
69 if (vaddr < PHB_IO_BASE || vaddr >= PHB_IO_END)
70 return NULL;
71
72 paddr = ppc_find_vmap_phys(vaddr);
73
74 bus = iowa_pci_find(vaddr, paddr);
75
76 if (bus == NULL)
77 return NULL;
78 }
79
80 return bus;
81}
82#else /* CONFIG_PPC_INDIRECT_MMIO */
83struct iowa_bus *iowa_mem_find_bus(const PCI_IO_ADDR addr)
84{
85 return NULL;
86}
87#endif /* !CONFIG_PPC_INDIRECT_MMIO */
88
89#ifdef CONFIG_PPC_INDIRECT_PIO
90struct iowa_bus *iowa_pio_find_bus(unsigned long port)
91{
92 unsigned long vaddr = (unsigned long)pci_io_base + port;
93 return iowa_pci_find(vaddr, 0);
94}
95#else
96struct iowa_bus *iowa_pio_find_bus(unsigned long port)
97{
98 return NULL;
99}
100#endif
101
102#define DEF_PCI_AC_RET(name, ret, at, al, space, aa) \
103static ret iowa_##name at \
104{ \
105 struct iowa_bus *bus; \
106 bus = iowa_##space##_find_bus(aa); \
107 if (bus && bus->ops && bus->ops->name) \
108 return bus->ops->name al; \
109 return __do_##name al; \
110}
111
112#define DEF_PCI_AC_NORET(name, at, al, space, aa) \
113static void iowa_##name at \
114{ \
115 struct iowa_bus *bus; \
116 bus = iowa_##space##_find_bus(aa); \
117 if (bus && bus->ops && bus->ops->name) { \
118 bus->ops->name al; \
119 return; \
120 } \
121 __do_##name al; \
122}
123
124#include <asm/io-defs.h>
125
126#undef DEF_PCI_AC_RET
127#undef DEF_PCI_AC_NORET
128
129static const struct ppc_pci_io iowa_pci_io = {
130
131#define DEF_PCI_AC_RET(name, ret, at, al, space, aa) .name = iowa_##name,
132#define DEF_PCI_AC_NORET(name, at, al, space, aa) .name = iowa_##name,
133
134#include <asm/io-defs.h>
135
136#undef DEF_PCI_AC_RET
137#undef DEF_PCI_AC_NORET
138
139};
140
141#ifdef CONFIG_PPC_INDIRECT_MMIO
142void __iomem *iowa_ioremap(phys_addr_t addr, unsigned long size,
143 pgprot_t prot, void *caller)
144{
145 struct iowa_bus *bus;
146 void __iomem *res = __ioremap_caller(addr, size, prot, caller);
147 int busno;
148
149 bus = iowa_pci_find(0, (unsigned long)addr);
150 if (bus != NULL) {
151 busno = bus - iowa_busses;
152 PCI_SET_ADDR_TOKEN(res, busno + 1);
153 }
154 return res;
155}
156#endif /* !CONFIG_PPC_INDIRECT_MMIO */
157
158bool io_workaround_inited;
159
160/* Enable IO workaround */
161static void io_workaround_init(void)
162{
163 if (io_workaround_inited)
164 return;
165 ppc_pci_io = iowa_pci_io;
166 io_workaround_inited = true;
167}
168
169/* Register new bus to support workaround */
170void iowa_register_bus(struct pci_controller *phb, struct ppc_pci_io *ops,
171 int (*initfunc)(struct iowa_bus *, void *), void *data)
172{
173 struct iowa_bus *bus;
174 struct device_node *np = phb->dn;
175
176 io_workaround_init();
177
178 if (iowa_bus_count >= IOWA_MAX_BUS) {
179 pr_err("IOWA:Too many pci bridges, "
180 "workarounds disabled for %pOF\n", np);
181 return;
182 }
183
184 bus = &iowa_busses[iowa_bus_count];
185 bus->phb = phb;
186 bus->ops = ops;
187 bus->private = data;
188
189 if (initfunc)
190 if ((*initfunc)(bus, data))
191 return;
192
193 iowa_bus_count++;
194
195 pr_debug("IOWA:[%d]Add bus, %pOF.\n", iowa_bus_count-1, np);
196}
197
1/*
2 * Support PCI IO workaround
3 *
4 * Copyright (C) 2006 Benjamin Herrenschmidt <benh@kernel.crashing.org>
5 * IBM, Corp.
6 * (C) Copyright 2007-2008 TOSHIBA CORPORATION
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation.
11 */
12#undef DEBUG
13
14#include <linux/kernel.h>
15#include <linux/sched.h> /* for init_mm */
16
17#include <asm/io.h>
18#include <asm/machdep.h>
19#include <asm/pgtable.h>
20#include <asm/ppc-pci.h>
21#include <asm/io-workarounds.h>
22
23#define IOWA_MAX_BUS 8
24
25static struct iowa_bus iowa_busses[IOWA_MAX_BUS];
26static unsigned int iowa_bus_count;
27
28static struct iowa_bus *iowa_pci_find(unsigned long vaddr, unsigned long paddr)
29{
30 int i, j;
31 struct resource *res;
32 unsigned long vstart, vend;
33
34 for (i = 0; i < iowa_bus_count; i++) {
35 struct iowa_bus *bus = &iowa_busses[i];
36 struct pci_controller *phb = bus->phb;
37
38 if (vaddr) {
39 vstart = (unsigned long)phb->io_base_virt;
40 vend = vstart + phb->pci_io_size - 1;
41 if ((vaddr >= vstart) && (vaddr <= vend))
42 return bus;
43 }
44
45 if (paddr)
46 for (j = 0; j < 3; j++) {
47 res = &phb->mem_resources[j];
48 if (paddr >= res->start && paddr <= res->end)
49 return bus;
50 }
51 }
52
53 return NULL;
54}
55
56struct iowa_bus *iowa_mem_find_bus(const PCI_IO_ADDR addr)
57{
58 struct iowa_bus *bus;
59 int token;
60
61 token = PCI_GET_ADDR_TOKEN(addr);
62
63 if (token && token <= iowa_bus_count)
64 bus = &iowa_busses[token - 1];
65 else {
66 unsigned long vaddr, paddr;
67 pte_t *ptep;
68
69 vaddr = (unsigned long)PCI_FIX_ADDR(addr);
70 if (vaddr < PHB_IO_BASE || vaddr >= PHB_IO_END)
71 return NULL;
72
73 ptep = find_linux_pte(init_mm.pgd, vaddr);
74 if (ptep == NULL)
75 paddr = 0;
76 else
77 paddr = pte_pfn(*ptep) << PAGE_SHIFT;
78 bus = iowa_pci_find(vaddr, paddr);
79
80 if (bus == NULL)
81 return NULL;
82 }
83
84 return bus;
85}
86
87struct iowa_bus *iowa_pio_find_bus(unsigned long port)
88{
89 unsigned long vaddr = (unsigned long)pci_io_base + port;
90 return iowa_pci_find(vaddr, 0);
91}
92
93
94#define DEF_PCI_AC_RET(name, ret, at, al, space, aa) \
95static ret iowa_##name at \
96{ \
97 struct iowa_bus *bus; \
98 bus = iowa_##space##_find_bus(aa); \
99 if (bus && bus->ops && bus->ops->name) \
100 return bus->ops->name al; \
101 return __do_##name al; \
102}
103
104#define DEF_PCI_AC_NORET(name, at, al, space, aa) \
105static void iowa_##name at \
106{ \
107 struct iowa_bus *bus; \
108 bus = iowa_##space##_find_bus(aa); \
109 if (bus && bus->ops && bus->ops->name) { \
110 bus->ops->name al; \
111 return; \
112 } \
113 __do_##name al; \
114}
115
116#include <asm/io-defs.h>
117
118#undef DEF_PCI_AC_RET
119#undef DEF_PCI_AC_NORET
120
121static const struct ppc_pci_io __devinitconst iowa_pci_io = {
122
123#define DEF_PCI_AC_RET(name, ret, at, al, space, aa) .name = iowa_##name,
124#define DEF_PCI_AC_NORET(name, at, al, space, aa) .name = iowa_##name,
125
126#include <asm/io-defs.h>
127
128#undef DEF_PCI_AC_RET
129#undef DEF_PCI_AC_NORET
130
131};
132
133static void __iomem *iowa_ioremap(phys_addr_t addr, unsigned long size,
134 unsigned long flags, void *caller)
135{
136 struct iowa_bus *bus;
137 void __iomem *res = __ioremap_caller(addr, size, flags, caller);
138 int busno;
139
140 bus = iowa_pci_find(0, (unsigned long)addr);
141 if (bus != NULL) {
142 busno = bus - iowa_busses;
143 PCI_SET_ADDR_TOKEN(res, busno + 1);
144 }
145 return res;
146}
147
148/* Enable IO workaround */
149static void __devinit io_workaround_init(void)
150{
151 static int io_workaround_inited;
152
153 if (io_workaround_inited)
154 return;
155 ppc_pci_io = iowa_pci_io;
156 ppc_md.ioremap = iowa_ioremap;
157 io_workaround_inited = 1;
158}
159
160/* Register new bus to support workaround */
161void __devinit iowa_register_bus(struct pci_controller *phb,
162 struct ppc_pci_io *ops,
163 int (*initfunc)(struct iowa_bus *, void *), void *data)
164{
165 struct iowa_bus *bus;
166 struct device_node *np = phb->dn;
167
168 io_workaround_init();
169
170 if (iowa_bus_count >= IOWA_MAX_BUS) {
171 pr_err("IOWA:Too many pci bridges, "
172 "workarounds disabled for %s\n", np->full_name);
173 return;
174 }
175
176 bus = &iowa_busses[iowa_bus_count];
177 bus->phb = phb;
178 bus->ops = ops;
179 bus->private = data;
180
181 if (initfunc)
182 if ((*initfunc)(bus, data))
183 return;
184
185 iowa_bus_count++;
186
187 pr_debug("IOWA:[%d]Add bus, %s.\n", iowa_bus_count-1, np->full_name);
188}
189