summaryrefslogtreecommitdiff
path: root/arch/powerpc/platforms/cell/spider-pci.c
blob: e36ebd84f55b811cabd42762f086ebc16610d28c (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * IO workarounds for PCI on Celleb/Cell platform
 *
 * (C) Copyright 2006-2007 TOSHIBA CORPORATION
 */

#undef DEBUG

#include <linux/kernel.h>
#include <linux/of_address.h>
#include <linux/of_platform.h>
#include <linux/slab.h>
#include <linux/io.h>

#include <asm/ppc-pci.h>
#include <asm/pci-bridge.h>
#include <asm/io-workarounds.h>

#define SPIDER_PCI_DISABLE_PREFETCH

struct spiderpci_iowa_private {
	void __iomem *regs;
};

static void spiderpci_io_flush(struct iowa_bus *bus)
{
	struct spiderpci_iowa_private *priv;

	priv = bus->private;
	in_be32(priv->regs + SPIDER_PCI_DUMMY_READ);
	iosync();
}

#define SPIDER_PCI_MMIO_READ(name, ret)					\
static ret spiderpci_##name(const PCI_IO_ADDR addr)			\
{									\
	ret val = __do_##name(addr);					\
	spiderpci_io_flush(iowa_mem_find_bus(addr));			\
	return val;							\
}

#define SPIDER_PCI_MMIO_READ_STR(name)					\
static void spiderpci_##name(const PCI_IO_ADDR addr, void *buf, 	\
			     unsigned long count)			\
{									\
	__do_##name(addr, buf, count);					\
	spiderpci_io_flush(iowa_mem_find_bus(addr));			\
}

SPIDER_PCI_MMIO_READ(readb, u8)
SPIDER_PCI_MMIO_READ(readw, u16)
SPIDER_PCI_MMIO_READ(readl, u32)
SPIDER_PCI_MMIO_READ(readq, u64)
SPIDER_PCI_MMIO_READ(readw_be, u16)
SPIDER_PCI_MMIO_READ(readl_be, u32)
SPIDER_PCI_MMIO_READ(readq_be, u64)
SPIDER_PCI_MMIO_READ_STR(readsb)
SPIDER_PCI_MMIO_READ_STR(readsw)
SPIDER_PCI_MMIO_READ_STR(readsl)

static void spiderpci_memcpy_fromio(void *dest, const PCI_IO_ADDR src,
				    unsigned long n)
{
	__do_memcpy_fromio(dest, src, n);
	spiderpci_io_flush(iowa_mem_find_bus(src));
}

static int __init spiderpci_pci_setup_chip(struct pci_controller *phb,
					   void __iomem *regs)
{
	void *dummy_page_va;
	dma_addr_t dummy_page_da;

#ifdef SPIDER_PCI_DISABLE_PREFETCH
	u32 val = in_be32(regs + SPIDER_PCI_VCI_CNTL_STAT);
	pr_debug("SPIDER_IOWA:PVCI_Control_Status was 0x%08x\n", val);
	out_be32(regs + SPIDER_PCI_VCI_CNTL_STAT, val | 0x8);
#endif /* SPIDER_PCI_DISABLE_PREFETCH */

	/* setup dummy read */
	/*
	 * On CellBlade, we can't know that which XDR memory is used by
	 * kmalloc() to allocate dummy_page_va.
	 * In order to improve the performance, the XDR which is used to
	 * allocate dummy_page_va is the nearest the spider-pci.
	 * We have to select the CBE which is the nearest the spider-pci
	 * to allocate memory from the best XDR, but I don't know that
	 * how to do.
	 *
	 * Celleb does not have this problem, because it has only one XDR.
	 */
	dummy_page_va = kmalloc(PAGE_SIZE, GFP_KERNEL);
	if (!dummy_page_va) {
		pr_err("SPIDERPCI-IOWA:Alloc dummy_page_va failed.\n");
		return -1;
	}

	dummy_page_da = dma_map_single(phb->parent, dummy_page_va,
				       PAGE_SIZE, DMA_FROM_DEVICE);
	if (dma_mapping_error(phb->parent, dummy_page_da)) {
		pr_err("SPIDER-IOWA:Map dummy page filed.\n");
		kfree(dummy_page_va);
		return -1;
	}

	out_be32(regs + SPIDER_PCI_DUMMY_READ_BASE, dummy_page_da);

	return 0;
}

int __init spiderpci_iowa_init(struct iowa_bus *bus, void *data)
{
	void __iomem *regs = NULL;
	struct spiderpci_iowa_private *priv;
	struct device_node *np = bus->phb->dn;
	struct resource r;
	unsigned long offset = (unsigned long)data;

	pr_debug("SPIDERPCI-IOWA:Bus initialize for spider(%pOF)\n",
		 np);

	priv = kzalloc(sizeof(*priv), GFP_KERNEL);
	if (!priv) {
		pr_err("SPIDERPCI-IOWA:"
		       "Can't allocate struct spiderpci_iowa_private");
		return -1;
	}

	if (of_address_to_resource(np, 0, &r)) {
		pr_err("SPIDERPCI-IOWA:Can't get resource.\n");
		goto error;
	}

	regs = ioremap(r.start + offset, SPIDER_PCI_REG_SIZE);
	if (!regs) {
		pr_err("SPIDERPCI-IOWA:ioremap failed.\n");
		goto error;
	}
	priv->regs = regs;
	bus->private = priv;

	if (spiderpci_pci_setup_chip(bus->phb, regs))
		goto error;

	return 0;

error:
	kfree(priv);
	bus->private = NULL;

	if (regs)
		iounmap(regs);

	return -1;
}

struct ppc_pci_io spiderpci_ops = {
	.readb = spiderpci_readb,
	.readw = spiderpci_readw,
	.readl = spiderpci_readl,
	.readq = spiderpci_readq,
	.readw_be = spiderpci_readw_be,
	.readl_be = spiderpci_readl_be,
	.readq_be = spiderpci_readq_be,
	.readsb = spiderpci_readsb,
	.readsw = spiderpci_readsw,
	.readsl = spiderpci_readsl,
	.memcpy_fromio = spiderpci_memcpy_fromio,
};