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	unsigned hugepage_shift;
 59	struct iowa_bus *bus;
 60	int token;
 61
 62	token = PCI_GET_ADDR_TOKEN(addr);
 63
 64	if (token && token <= iowa_bus_count)
 65		bus = &iowa_busses[token - 1];
 66	else {
 67		unsigned long vaddr, paddr;
 68		pte_t *ptep;
 69
 70		vaddr = (unsigned long)PCI_FIX_ADDR(addr);
 71		if (vaddr < PHB_IO_BASE || vaddr >= PHB_IO_END)
 72			return NULL;
 73		/*
 74		 * We won't find huge pages here (iomem). Also can't hit
 75		 * a page table free due to init_mm
 76		 */
 77		ptep = find_init_mm_pte(vaddr, &hugepage_shift);
 78		if (ptep == NULL)
 79			paddr = 0;
 80		else {
 81			WARN_ON(hugepage_shift);
 82			paddr = pte_pfn(*ptep) << PAGE_SHIFT;
 83		}
 84		bus = iowa_pci_find(vaddr, paddr);
 85
 86		if (bus == NULL)
 87			return NULL;
 88	}
 89
 90	return bus;
 91}
 92#else /* CONFIG_PPC_INDIRECT_MMIO */
 93struct iowa_bus *iowa_mem_find_bus(const PCI_IO_ADDR addr)
 94{
 95	return NULL;
 96}
 97#endif /* !CONFIG_PPC_INDIRECT_MMIO */
 98
 99#ifdef CONFIG_PPC_INDIRECT_PIO
100struct iowa_bus *iowa_pio_find_bus(unsigned long port)
101{
102	unsigned long vaddr = (unsigned long)pci_io_base + port;
103	return iowa_pci_find(vaddr, 0);
104}
105#else
106struct iowa_bus *iowa_pio_find_bus(unsigned long port)
107{
108	return NULL;
109}
110#endif
111
112#define DEF_PCI_AC_RET(name, ret, at, al, space, aa)		\
113static ret 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		return bus->ops->name al;			\
119	return __do_##name al;					\
120}
121
122#define DEF_PCI_AC_NORET(name, at, al, space, aa)		\
123static void iowa_##name at					\
124{								\
125	struct iowa_bus *bus;					\
126	bus = iowa_##space##_find_bus(aa);			\
127	if (bus && bus->ops && bus->ops->name) {		\
128		bus->ops->name al;				\
129		return;						\
130	}							\
131	__do_##name al;						\
132}
133
134#include <asm/io-defs.h>
135
136#undef DEF_PCI_AC_RET
137#undef DEF_PCI_AC_NORET
138
139static const struct ppc_pci_io iowa_pci_io = {
140
141#define DEF_PCI_AC_RET(name, ret, at, al, space, aa)	.name = iowa_##name,
142#define DEF_PCI_AC_NORET(name, at, al, space, aa)	.name = iowa_##name,
143
144#include <asm/io-defs.h>
145
146#undef DEF_PCI_AC_RET
147#undef DEF_PCI_AC_NORET
148
149};
150
151#ifdef CONFIG_PPC_INDIRECT_MMIO
152void __iomem *iowa_ioremap(phys_addr_t addr, unsigned long size,
153			   pgprot_t prot, void *caller)
154{
155	struct iowa_bus *bus;
156	void __iomem *res = __ioremap_caller(addr, size, prot, caller);
157	int busno;
158
159	bus = iowa_pci_find(0, (unsigned long)addr);
160	if (bus != NULL) {
161		busno = bus - iowa_busses;
162		PCI_SET_ADDR_TOKEN(res, busno + 1);
163	}
164	return res;
165}
166#endif /* !CONFIG_PPC_INDIRECT_MMIO */
167
168bool io_workaround_inited;
169
170/* Enable IO workaround */
171static void io_workaround_init(void)
172{
 
 
173	if (io_workaround_inited)
174		return;
175	ppc_pci_io = iowa_pci_io;
176	io_workaround_inited = true;
 
177}
178
179/* Register new bus to support workaround */
180void iowa_register_bus(struct pci_controller *phb, struct ppc_pci_io *ops,
181		       int (*initfunc)(struct iowa_bus *, void *), void *data)
 
182{
183	struct iowa_bus *bus;
184	struct device_node *np = phb->dn;
185
186	io_workaround_init();
187
188	if (iowa_bus_count >= IOWA_MAX_BUS) {
189		pr_err("IOWA:Too many pci bridges, "
190		       "workarounds disabled for %pOF\n", np);
191		return;
192	}
193
194	bus = &iowa_busses[iowa_bus_count];
195	bus->phb = phb;
196	bus->ops = ops;
197	bus->private = data;
198
199	if (initfunc)
200		if ((*initfunc)(bus, data))
201			return;
202
203	iowa_bus_count++;
204
205	pr_debug("IOWA:[%d]Add bus, %pOF.\n", iowa_bus_count-1, np);
206}
207

 
  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