blob: 49e9c664ea89b0745829dfd52058f620b35fdb27 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 * Copyright (C) 2001 Mike Corrigan & Dave Engebretsen, IBM Corporation
3 *
4 * Rewrite, cleanup:
5 *
Olof Johansson91f14482005-11-21 02:12:32 -06006 * Copyright (C) 2004 Olof Johansson <olof@lixom.net>, IBM Corporation
Olof Johanssonbc97ce92006-04-28 22:51:59 -05007 * Copyright (C) 2006 Olof Johansson <olof@lixom.net>
Linus Torvalds1da177e2005-04-16 15:20:36 -07008 *
9 * Dynamic DMA mapping support, iSeries-specific parts.
10 *
11 *
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * (at your option) any later version.
16 *
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 */
26
27#include <linux/types.h>
28#include <linux/dma-mapping.h>
29#include <linux/list.h>
Benjamin Herrenschmidt12d04ee2006-11-11 17:25:02 +110030#include <linux/pci.h>
Stephen Rothwell1670b2b2007-10-11 14:53:32 +100031#include <linux/module.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070032
33#include <asm/iommu.h>
Stephen Rothwelldd9b67a2007-10-11 14:55:02 +100034#include <asm/vio.h>
Olof Johanssonc707ffc2005-09-20 13:45:41 +100035#include <asm/tce.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070036#include <asm/machdep.h>
Stephen Rothwell426c1a12005-10-14 14:51:42 +100037#include <asm/abs_addr.h>
Stephen Rothwell96ff6af2006-05-19 16:48:47 +100038#include <asm/prom.h>
Stephen Rothwellbffa8fc2005-10-14 15:06:10 +100039#include <asm/pci-bridge.h>
Kelly Daly8021b8a2005-11-02 11:41:12 +110040#include <asm/iseries/hv_call_xm.h>
Stephen Rothwell1670b2b2007-10-11 14:53:32 +100041#include <asm/iseries/hv_call_event.h>
Stephen Rothwellc7f0e8c2006-04-27 17:23:32 +100042#include <asm/iseries/iommu.h>
Stephen Rothwell9bd7ea62006-01-12 13:58:19 +110043
Linus Torvalds1da177e2005-04-16 15:20:36 -070044static void tce_build_iSeries(struct iommu_table *tbl, long index, long npages,
45 unsigned long uaddr, enum dma_data_direction direction)
46{
47 u64 rc;
Olof Johanssonbc97ce92006-04-28 22:51:59 -050048 u64 tce, rpn;
Linus Torvalds1da177e2005-04-16 15:20:36 -070049
50 while (npages--) {
Olof Johanssonbc97ce92006-04-28 22:51:59 -050051 rpn = virt_to_abs(uaddr) >> TCE_SHIFT;
52 tce = (rpn & TCE_RPN_MASK) << TCE_RPN_SHIFT;
Linus Torvalds1da177e2005-04-16 15:20:36 -070053
54 if (tbl->it_type == TCE_VB) {
55 /* Virtual Bus */
Olof Johanssonbc97ce92006-04-28 22:51:59 -050056 tce |= TCE_VALID|TCE_ALLIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -070057 if (direction != DMA_TO_DEVICE)
Olof Johanssonbc97ce92006-04-28 22:51:59 -050058 tce |= TCE_VB_WRITE;
Linus Torvalds1da177e2005-04-16 15:20:36 -070059 } else {
60 /* PCI Bus */
Olof Johanssonbc97ce92006-04-28 22:51:59 -050061 tce |= TCE_PCI_READ; /* Read allowed */
Linus Torvalds1da177e2005-04-16 15:20:36 -070062 if (direction != DMA_TO_DEVICE)
Olof Johanssonbc97ce92006-04-28 22:51:59 -050063 tce |= TCE_PCI_WRITE;
Linus Torvalds1da177e2005-04-16 15:20:36 -070064 }
65
Olof Johanssonbc97ce92006-04-28 22:51:59 -050066 rc = HvCallXm_setTce((u64)tbl->it_index, (u64)index, tce);
Linus Torvalds1da177e2005-04-16 15:20:36 -070067 if (rc)
68 panic("PCI_DMA: HvCallXm_setTce failed, Rc: 0x%lx\n",
69 rc);
70 index++;
Benjamin Herrenschmidt3c726f82005-11-07 11:06:55 +110071 uaddr += TCE_PAGE_SIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -070072 }
73}
74
75static void tce_free_iSeries(struct iommu_table *tbl, long index, long npages)
76{
77 u64 rc;
78
79 while (npages--) {
80 rc = HvCallXm_setTce((u64)tbl->it_index, (u64)index, 0);
81 if (rc)
82 panic("PCI_DMA: HvCallXm_setTce failed, Rc: 0x%lx\n",
83 rc);
84 index++;
85 }
86}
87
Benjamin Herrenschmidt3c726f82005-11-07 11:06:55 +110088/*
Michael Ellermanca652c92006-07-14 14:25:33 +100089 * Structure passed to HvCallXm_getTceTableParms
90 */
91struct iommu_table_cb {
92 unsigned long itc_busno; /* Bus number for this tce table */
93 unsigned long itc_start; /* Will be NULL for secondary */
94 unsigned long itc_totalsize; /* Size (in pages) of whole table */
95 unsigned long itc_offset; /* Index into real tce table of the
96 start of our section */
97 unsigned long itc_size; /* Size (in pages) of our section */
98 unsigned long itc_index; /* Index of this tce table */
99 unsigned short itc_maxtables; /* Max num of tables for partition */
100 unsigned char itc_virtbus; /* Flag to indicate virtual bus */
101 unsigned char itc_slotno; /* IOA Tce Slot Index */
102 unsigned char itc_rsvd[4];
103};
104
105/*
Benjamin Herrenschmidt3c726f82005-11-07 11:06:55 +1100106 * Call Hv with the architected data structure to get TCE table info.
107 * info. Put the returned data into the Linux representation of the
108 * TCE table data.
109 * The Hardware Tce table comes in three flavors.
110 * 1. TCE table shared between Buses.
111 * 2. TCE table per Bus.
112 * 3. TCE Table per IOA.
113 */
114void iommu_table_getparms_iSeries(unsigned long busno,
115 unsigned char slotno,
116 unsigned char virtbus,
117 struct iommu_table* tbl)
118{
119 struct iommu_table_cb *parms;
120
Yan Burmanf8485352006-12-02 13:26:57 +0200121 parms = kzalloc(sizeof(*parms), GFP_KERNEL);
Benjamin Herrenschmidt3c726f82005-11-07 11:06:55 +1100122 if (parms == NULL)
123 panic("PCI_DMA: TCE Table Allocation failed.");
124
Benjamin Herrenschmidt3c726f82005-11-07 11:06:55 +1100125 parms->itc_busno = busno;
126 parms->itc_slotno = slotno;
127 parms->itc_virtbus = virtbus;
128
129 HvCallXm_getTceTableParms(iseries_hv_addr(parms));
130
131 if (parms->itc_size == 0)
132 panic("PCI_DMA: parms->size is zero, parms is 0x%p", parms);
133
134 /* itc_size is in pages worth of table, it_size is in # of entries */
Linas Vepstas5d2efba2006-10-30 16:15:59 +1100135 tbl->it_size = (parms->itc_size * TCE_PAGE_SIZE) / TCE_ENTRY_SIZE;
Benjamin Herrenschmidt3c726f82005-11-07 11:06:55 +1100136 tbl->it_busno = parms->itc_busno;
Linas Vepstas5d2efba2006-10-30 16:15:59 +1100137 tbl->it_offset = parms->itc_offset;
Benjamin Herrenschmidt3c726f82005-11-07 11:06:55 +1100138 tbl->it_index = parms->itc_index;
139 tbl->it_blocksize = 1;
140 tbl->it_type = virtbus ? TCE_VB : TCE_PCI;
141
142 kfree(parms);
143}
144
145
Stephen Rothwell145d01e2005-06-21 17:15:52 -0700146#ifdef CONFIG_PCI
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147/*
148 * This function compares the known tables to find an iommu_table
149 * that has already been built for hardware TCEs.
150 */
151static struct iommu_table *iommu_table_find(struct iommu_table * tbl)
152{
Stephen Rothwell96ff6af2006-05-19 16:48:47 +1000153 struct device_node *node;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154
Stephen Rothwell96ff6af2006-05-19 16:48:47 +1000155 for (node = NULL; (node = of_find_all_nodes(node)); ) {
156 struct pci_dn *pdn = PCI_DN(node);
157 struct iommu_table *it;
158
159 if (pdn == NULL)
160 continue;
161 it = pdn->iommu_table;
Stephen Rothwell252e75a2005-09-28 14:40:40 +1000162 if ((it != NULL) &&
163 (it->it_type == TCE_PCI) &&
164 (it->it_offset == tbl->it_offset) &&
165 (it->it_index == tbl->it_index) &&
166 (it->it_size == tbl->it_size))
167 return it;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168 }
169 return NULL;
170}
171
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172
Benjamin Herrenschmidt12d04ee2006-11-11 17:25:02 +1100173void iommu_devnode_init_iSeries(struct pci_dev *pdev, struct device_node *dn)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174{
175 struct iommu_table *tbl;
Stephen Rothwell252e75a2005-09-28 14:40:40 +1000176 struct pci_dn *pdn = PCI_DN(dn);
Stephen Rothwelle2eb6392007-04-03 22:26:41 +1000177 const u32 *lsn = of_get_property(dn, "linux,logical-slot-number", NULL);
Stephen Rothwell403fac42006-05-19 16:51:57 +1000178
179 BUG_ON(lsn == NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180
181 tbl = kmalloc(sizeof(struct iommu_table), GFP_KERNEL);
182
Stephen Rothwell403fac42006-05-19 16:51:57 +1000183 iommu_table_getparms_iSeries(pdn->busno, *lsn, 0, tbl);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184
185 /* Look for existing tce table */
Stephen Rothwell252e75a2005-09-28 14:40:40 +1000186 pdn->iommu_table = iommu_table_find(tbl);
187 if (pdn->iommu_table == NULL)
Anton Blanchardca1588e2006-06-10 20:58:08 +1000188 pdn->iommu_table = iommu_init_table(tbl, -1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189 else
190 kfree(tbl);
Benjamin Herrenschmidt12d04ee2006-11-11 17:25:02 +1100191 pdev->dev.archdata.dma_data = pdn->iommu_table;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192}
Stephen Rothwell145d01e2005-06-21 17:15:52 -0700193#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194
Stephen Rothwelldd9b67a2007-10-11 14:55:02 +1000195static struct iommu_table veth_iommu_table;
196static struct iommu_table vio_iommu_table;
Stephen Rothwell1670b2b2007-10-11 14:53:32 +1000197
198void *iseries_hv_alloc(size_t size, dma_addr_t *dma_handle, gfp_t flag)
199{
200 return iommu_alloc_coherent(&vio_iommu_table, size, dma_handle,
201 DMA_32BIT_MASK, flag, -1);
202}
203EXPORT_SYMBOL_GPL(iseries_hv_alloc);
204
205void iseries_hv_free(size_t size, void *vaddr, dma_addr_t dma_handle)
206{
207 iommu_free_coherent(&vio_iommu_table, size, vaddr, dma_handle);
208}
209EXPORT_SYMBOL_GPL(iseries_hv_free);
210
211dma_addr_t iseries_hv_map(void *vaddr, size_t size,
212 enum dma_data_direction direction)
213{
214 return iommu_map_single(&vio_iommu_table, vaddr, size,
215 DMA_32BIT_MASK, direction);
216}
217
218void iseries_hv_unmap(dma_addr_t dma_handle, size_t size,
219 enum dma_data_direction direction)
220{
221 iommu_unmap_single(&vio_iommu_table, dma_handle, size, direction);
222}
223
Stephen Rothwelldd9b67a2007-10-11 14:55:02 +1000224void __init iommu_vio_init(void)
225{
226 iommu_table_getparms_iSeries(255, 0, 0xff, &veth_iommu_table);
227 veth_iommu_table.it_size /= 2;
228 vio_iommu_table = veth_iommu_table;
229 vio_iommu_table.it_offset += veth_iommu_table.it_size;
230
231 if (!iommu_init_table(&veth_iommu_table, -1))
232 printk("Virtual Bus VETH TCE table failed.\n");
233 if (!iommu_init_table(&vio_iommu_table, -1))
234 printk("Virtual Bus VIO TCE table failed.\n");
235}
236
237struct iommu_table *vio_build_iommu_table_iseries(struct vio_dev *dev)
238{
239 if (strcmp(dev->type, "network") == 0)
240 return &veth_iommu_table;
241 return &vio_iommu_table;
242}
243
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244void iommu_init_early_iSeries(void)
245{
246 ppc_md.tce_build = tce_build_iSeries;
247 ppc_md.tce_free = tce_free_iSeries;
248
Stephen Rothwell98747772007-03-04 16:58:39 +1100249 set_pci_dma_ops(&dma_iommu_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250}