Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2 | * Copyright (C) 2001 Mike Corrigan & Dave Engebretsen, IBM Corporation |
| 3 | * |
| 4 | * Rewrite, cleanup: |
| 5 | * |
Olof Johansson | 91f1448 | 2005-11-21 02:12:32 -0600 | [diff] [blame] | 6 | * Copyright (C) 2004 Olof Johansson <olof@lixom.net>, IBM Corporation |
Olof Johansson | bc97ce9 | 2006-04-28 22:51:59 -0500 | [diff] [blame] | 7 | * Copyright (C) 2006 Olof Johansson <olof@lixom.net> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 8 | * |
| 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 Herrenschmidt | 12d04ee | 2006-11-11 17:25:02 +1100 | [diff] [blame] | 30 | #include <linux/pci.h> |
Stephen Rothwell | 1670b2b | 2007-10-11 14:53:32 +1000 | [diff] [blame] | 31 | #include <linux/module.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 32 | |
| 33 | #include <asm/iommu.h> |
Stephen Rothwell | dd9b67a | 2007-10-11 14:55:02 +1000 | [diff] [blame] | 34 | #include <asm/vio.h> |
Olof Johansson | c707ffc | 2005-09-20 13:45:41 +1000 | [diff] [blame] | 35 | #include <asm/tce.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 36 | #include <asm/machdep.h> |
Stephen Rothwell | 426c1a1 | 2005-10-14 14:51:42 +1000 | [diff] [blame] | 37 | #include <asm/abs_addr.h> |
Stephen Rothwell | 96ff6af | 2006-05-19 16:48:47 +1000 | [diff] [blame] | 38 | #include <asm/prom.h> |
Stephen Rothwell | bffa8fc | 2005-10-14 15:06:10 +1000 | [diff] [blame] | 39 | #include <asm/pci-bridge.h> |
Kelly Daly | 8021b8a | 2005-11-02 11:41:12 +1100 | [diff] [blame] | 40 | #include <asm/iseries/hv_call_xm.h> |
Stephen Rothwell | 1670b2b | 2007-10-11 14:53:32 +1000 | [diff] [blame] | 41 | #include <asm/iseries/hv_call_event.h> |
Stephen Rothwell | c7f0e8c | 2006-04-27 17:23:32 +1000 | [diff] [blame] | 42 | #include <asm/iseries/iommu.h> |
Stephen Rothwell | 9bd7ea6 | 2006-01-12 13:58:19 +1100 | [diff] [blame] | 43 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 44 | static void tce_build_iSeries(struct iommu_table *tbl, long index, long npages, |
Mark Nelson | 4f3dd8a | 2008-07-16 05:51:47 +1000 | [diff] [blame^] | 45 | unsigned long uaddr, enum dma_data_direction direction, |
| 46 | struct dma_attrs *attrs) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 47 | { |
| 48 | u64 rc; |
Olof Johansson | bc97ce9 | 2006-04-28 22:51:59 -0500 | [diff] [blame] | 49 | u64 tce, rpn; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 50 | |
| 51 | while (npages--) { |
Olof Johansson | bc97ce9 | 2006-04-28 22:51:59 -0500 | [diff] [blame] | 52 | rpn = virt_to_abs(uaddr) >> TCE_SHIFT; |
| 53 | tce = (rpn & TCE_RPN_MASK) << TCE_RPN_SHIFT; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 54 | |
| 55 | if (tbl->it_type == TCE_VB) { |
| 56 | /* Virtual Bus */ |
Olof Johansson | bc97ce9 | 2006-04-28 22:51:59 -0500 | [diff] [blame] | 57 | tce |= TCE_VALID|TCE_ALLIO; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 58 | if (direction != DMA_TO_DEVICE) |
Olof Johansson | bc97ce9 | 2006-04-28 22:51:59 -0500 | [diff] [blame] | 59 | tce |= TCE_VB_WRITE; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 60 | } else { |
| 61 | /* PCI Bus */ |
Olof Johansson | bc97ce9 | 2006-04-28 22:51:59 -0500 | [diff] [blame] | 62 | tce |= TCE_PCI_READ; /* Read allowed */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 63 | if (direction != DMA_TO_DEVICE) |
Olof Johansson | bc97ce9 | 2006-04-28 22:51:59 -0500 | [diff] [blame] | 64 | tce |= TCE_PCI_WRITE; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 65 | } |
| 66 | |
Olof Johansson | bc97ce9 | 2006-04-28 22:51:59 -0500 | [diff] [blame] | 67 | rc = HvCallXm_setTce((u64)tbl->it_index, (u64)index, tce); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 68 | if (rc) |
| 69 | panic("PCI_DMA: HvCallXm_setTce failed, Rc: 0x%lx\n", |
| 70 | rc); |
| 71 | index++; |
Benjamin Herrenschmidt | 3c726f8 | 2005-11-07 11:06:55 +1100 | [diff] [blame] | 72 | uaddr += TCE_PAGE_SIZE; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 73 | } |
| 74 | } |
| 75 | |
| 76 | static void tce_free_iSeries(struct iommu_table *tbl, long index, long npages) |
| 77 | { |
| 78 | u64 rc; |
| 79 | |
| 80 | while (npages--) { |
| 81 | rc = HvCallXm_setTce((u64)tbl->it_index, (u64)index, 0); |
| 82 | if (rc) |
| 83 | panic("PCI_DMA: HvCallXm_setTce failed, Rc: 0x%lx\n", |
| 84 | rc); |
| 85 | index++; |
| 86 | } |
| 87 | } |
| 88 | |
Benjamin Herrenschmidt | 3c726f8 | 2005-11-07 11:06:55 +1100 | [diff] [blame] | 89 | /* |
Michael Ellerman | ca652c9 | 2006-07-14 14:25:33 +1000 | [diff] [blame] | 90 | * Structure passed to HvCallXm_getTceTableParms |
| 91 | */ |
| 92 | struct iommu_table_cb { |
| 93 | unsigned long itc_busno; /* Bus number for this tce table */ |
| 94 | unsigned long itc_start; /* Will be NULL for secondary */ |
| 95 | unsigned long itc_totalsize; /* Size (in pages) of whole table */ |
| 96 | unsigned long itc_offset; /* Index into real tce table of the |
| 97 | start of our section */ |
| 98 | unsigned long itc_size; /* Size (in pages) of our section */ |
| 99 | unsigned long itc_index; /* Index of this tce table */ |
| 100 | unsigned short itc_maxtables; /* Max num of tables for partition */ |
| 101 | unsigned char itc_virtbus; /* Flag to indicate virtual bus */ |
| 102 | unsigned char itc_slotno; /* IOA Tce Slot Index */ |
| 103 | unsigned char itc_rsvd[4]; |
| 104 | }; |
| 105 | |
| 106 | /* |
Benjamin Herrenschmidt | 3c726f8 | 2005-11-07 11:06:55 +1100 | [diff] [blame] | 107 | * Call Hv with the architected data structure to get TCE table info. |
| 108 | * info. Put the returned data into the Linux representation of the |
| 109 | * TCE table data. |
| 110 | * The Hardware Tce table comes in three flavors. |
| 111 | * 1. TCE table shared between Buses. |
| 112 | * 2. TCE table per Bus. |
| 113 | * 3. TCE Table per IOA. |
| 114 | */ |
| 115 | void iommu_table_getparms_iSeries(unsigned long busno, |
| 116 | unsigned char slotno, |
| 117 | unsigned char virtbus, |
| 118 | struct iommu_table* tbl) |
| 119 | { |
| 120 | struct iommu_table_cb *parms; |
| 121 | |
Yan Burman | f848535 | 2006-12-02 13:26:57 +0200 | [diff] [blame] | 122 | parms = kzalloc(sizeof(*parms), GFP_KERNEL); |
Benjamin Herrenschmidt | 3c726f8 | 2005-11-07 11:06:55 +1100 | [diff] [blame] | 123 | if (parms == NULL) |
| 124 | panic("PCI_DMA: TCE Table Allocation failed."); |
| 125 | |
Benjamin Herrenschmidt | 3c726f8 | 2005-11-07 11:06:55 +1100 | [diff] [blame] | 126 | parms->itc_busno = busno; |
| 127 | parms->itc_slotno = slotno; |
| 128 | parms->itc_virtbus = virtbus; |
| 129 | |
| 130 | HvCallXm_getTceTableParms(iseries_hv_addr(parms)); |
| 131 | |
| 132 | if (parms->itc_size == 0) |
| 133 | panic("PCI_DMA: parms->size is zero, parms is 0x%p", parms); |
| 134 | |
| 135 | /* itc_size is in pages worth of table, it_size is in # of entries */ |
Linas Vepstas | 5d2efba | 2006-10-30 16:15:59 +1100 | [diff] [blame] | 136 | tbl->it_size = (parms->itc_size * TCE_PAGE_SIZE) / TCE_ENTRY_SIZE; |
Benjamin Herrenschmidt | 3c726f8 | 2005-11-07 11:06:55 +1100 | [diff] [blame] | 137 | tbl->it_busno = parms->itc_busno; |
Linas Vepstas | 5d2efba | 2006-10-30 16:15:59 +1100 | [diff] [blame] | 138 | tbl->it_offset = parms->itc_offset; |
Benjamin Herrenschmidt | 3c726f8 | 2005-11-07 11:06:55 +1100 | [diff] [blame] | 139 | tbl->it_index = parms->itc_index; |
| 140 | tbl->it_blocksize = 1; |
| 141 | tbl->it_type = virtbus ? TCE_VB : TCE_PCI; |
| 142 | |
| 143 | kfree(parms); |
| 144 | } |
| 145 | |
| 146 | |
Stephen Rothwell | 145d01e | 2005-06-21 17:15:52 -0700 | [diff] [blame] | 147 | #ifdef CONFIG_PCI |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 148 | /* |
| 149 | * This function compares the known tables to find an iommu_table |
| 150 | * that has already been built for hardware TCEs. |
| 151 | */ |
| 152 | static struct iommu_table *iommu_table_find(struct iommu_table * tbl) |
| 153 | { |
Stephen Rothwell | 96ff6af | 2006-05-19 16:48:47 +1000 | [diff] [blame] | 154 | struct device_node *node; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 155 | |
Stephen Rothwell | 96ff6af | 2006-05-19 16:48:47 +1000 | [diff] [blame] | 156 | for (node = NULL; (node = of_find_all_nodes(node)); ) { |
| 157 | struct pci_dn *pdn = PCI_DN(node); |
| 158 | struct iommu_table *it; |
| 159 | |
| 160 | if (pdn == NULL) |
| 161 | continue; |
| 162 | it = pdn->iommu_table; |
Stephen Rothwell | 252e75a | 2005-09-28 14:40:40 +1000 | [diff] [blame] | 163 | if ((it != NULL) && |
| 164 | (it->it_type == TCE_PCI) && |
| 165 | (it->it_offset == tbl->it_offset) && |
| 166 | (it->it_index == tbl->it_index) && |
Julia Lawall | af449c3 | 2007-12-13 15:56:15 -0800 | [diff] [blame] | 167 | (it->it_size == tbl->it_size)) { |
| 168 | of_node_put(node); |
Stephen Rothwell | 252e75a | 2005-09-28 14:40:40 +1000 | [diff] [blame] | 169 | return it; |
Julia Lawall | af449c3 | 2007-12-13 15:56:15 -0800 | [diff] [blame] | 170 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 171 | } |
| 172 | return NULL; |
| 173 | } |
| 174 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 175 | |
Benjamin Herrenschmidt | 12d04ee | 2006-11-11 17:25:02 +1100 | [diff] [blame] | 176 | void iommu_devnode_init_iSeries(struct pci_dev *pdev, struct device_node *dn) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 177 | { |
| 178 | struct iommu_table *tbl; |
Stephen Rothwell | 252e75a | 2005-09-28 14:40:40 +1000 | [diff] [blame] | 179 | struct pci_dn *pdn = PCI_DN(dn); |
Stephen Rothwell | e2eb639 | 2007-04-03 22:26:41 +1000 | [diff] [blame] | 180 | const u32 *lsn = of_get_property(dn, "linux,logical-slot-number", NULL); |
Stephen Rothwell | 403fac4 | 2006-05-19 16:51:57 +1000 | [diff] [blame] | 181 | |
| 182 | BUG_ON(lsn == NULL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 183 | |
| 184 | tbl = kmalloc(sizeof(struct iommu_table), GFP_KERNEL); |
| 185 | |
Stephen Rothwell | 403fac4 | 2006-05-19 16:51:57 +1000 | [diff] [blame] | 186 | iommu_table_getparms_iSeries(pdn->busno, *lsn, 0, tbl); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 187 | |
| 188 | /* Look for existing tce table */ |
Stephen Rothwell | 252e75a | 2005-09-28 14:40:40 +1000 | [diff] [blame] | 189 | pdn->iommu_table = iommu_table_find(tbl); |
| 190 | if (pdn->iommu_table == NULL) |
Anton Blanchard | ca1588e | 2006-06-10 20:58:08 +1000 | [diff] [blame] | 191 | pdn->iommu_table = iommu_init_table(tbl, -1); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 192 | else |
| 193 | kfree(tbl); |
Benjamin Herrenschmidt | 12d04ee | 2006-11-11 17:25:02 +1100 | [diff] [blame] | 194 | pdev->dev.archdata.dma_data = pdn->iommu_table; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 195 | } |
Stephen Rothwell | 145d01e | 2005-06-21 17:15:52 -0700 | [diff] [blame] | 196 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 197 | |
Stephen Rothwell | dd9b67a | 2007-10-11 14:55:02 +1000 | [diff] [blame] | 198 | static struct iommu_table veth_iommu_table; |
| 199 | static struct iommu_table vio_iommu_table; |
Stephen Rothwell | 1670b2b | 2007-10-11 14:53:32 +1000 | [diff] [blame] | 200 | |
| 201 | void *iseries_hv_alloc(size_t size, dma_addr_t *dma_handle, gfp_t flag) |
| 202 | { |
FUJITA Tomonori | fb3475e | 2008-02-04 22:28:08 -0800 | [diff] [blame] | 203 | return iommu_alloc_coherent(NULL, &vio_iommu_table, size, dma_handle, |
Stephen Rothwell | 1670b2b | 2007-10-11 14:53:32 +1000 | [diff] [blame] | 204 | DMA_32BIT_MASK, flag, -1); |
| 205 | } |
| 206 | EXPORT_SYMBOL_GPL(iseries_hv_alloc); |
| 207 | |
| 208 | void iseries_hv_free(size_t size, void *vaddr, dma_addr_t dma_handle) |
| 209 | { |
| 210 | iommu_free_coherent(&vio_iommu_table, size, vaddr, dma_handle); |
| 211 | } |
| 212 | EXPORT_SYMBOL_GPL(iseries_hv_free); |
| 213 | |
| 214 | dma_addr_t iseries_hv_map(void *vaddr, size_t size, |
| 215 | enum dma_data_direction direction) |
| 216 | { |
FUJITA Tomonori | fb3475e | 2008-02-04 22:28:08 -0800 | [diff] [blame] | 217 | return iommu_map_single(NULL, &vio_iommu_table, vaddr, size, |
Mark Nelson | 3affedc | 2008-07-05 05:05:42 +1000 | [diff] [blame] | 218 | DMA_32BIT_MASK, direction, NULL); |
Stephen Rothwell | 1670b2b | 2007-10-11 14:53:32 +1000 | [diff] [blame] | 219 | } |
| 220 | |
| 221 | void iseries_hv_unmap(dma_addr_t dma_handle, size_t size, |
| 222 | enum dma_data_direction direction) |
| 223 | { |
Mark Nelson | 3affedc | 2008-07-05 05:05:42 +1000 | [diff] [blame] | 224 | iommu_unmap_single(&vio_iommu_table, dma_handle, size, direction, NULL); |
Stephen Rothwell | 1670b2b | 2007-10-11 14:53:32 +1000 | [diff] [blame] | 225 | } |
| 226 | |
Stephen Rothwell | dd9b67a | 2007-10-11 14:55:02 +1000 | [diff] [blame] | 227 | void __init iommu_vio_init(void) |
| 228 | { |
| 229 | iommu_table_getparms_iSeries(255, 0, 0xff, &veth_iommu_table); |
| 230 | veth_iommu_table.it_size /= 2; |
| 231 | vio_iommu_table = veth_iommu_table; |
| 232 | vio_iommu_table.it_offset += veth_iommu_table.it_size; |
| 233 | |
| 234 | if (!iommu_init_table(&veth_iommu_table, -1)) |
| 235 | printk("Virtual Bus VETH TCE table failed.\n"); |
| 236 | if (!iommu_init_table(&vio_iommu_table, -1)) |
| 237 | printk("Virtual Bus VIO TCE table failed.\n"); |
| 238 | } |
| 239 | |
| 240 | struct iommu_table *vio_build_iommu_table_iseries(struct vio_dev *dev) |
| 241 | { |
| 242 | if (strcmp(dev->type, "network") == 0) |
| 243 | return &veth_iommu_table; |
| 244 | return &vio_iommu_table; |
| 245 | } |
| 246 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 247 | void iommu_init_early_iSeries(void) |
| 248 | { |
| 249 | ppc_md.tce_build = tce_build_iSeries; |
| 250 | ppc_md.tce_free = tce_free_iSeries; |
| 251 | |
Stephen Rothwell | 9874777 | 2007-03-04 16:58:39 +1100 | [diff] [blame] | 252 | set_pci_dma_ops(&dma_iommu_ops); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 253 | } |