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, |
| 45 | unsigned long uaddr, enum dma_data_direction direction) |
| 46 | { |
| 47 | u64 rc; |
Olof Johansson | bc97ce9 | 2006-04-28 22:51:59 -0500 | [diff] [blame] | 48 | u64 tce, rpn; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 49 | |
| 50 | while (npages--) { |
Olof Johansson | bc97ce9 | 2006-04-28 22:51:59 -0500 | [diff] [blame] | 51 | rpn = virt_to_abs(uaddr) >> TCE_SHIFT; |
| 52 | tce = (rpn & TCE_RPN_MASK) << TCE_RPN_SHIFT; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 53 | |
| 54 | if (tbl->it_type == TCE_VB) { |
| 55 | /* Virtual Bus */ |
Olof Johansson | bc97ce9 | 2006-04-28 22:51:59 -0500 | [diff] [blame] | 56 | tce |= TCE_VALID|TCE_ALLIO; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 57 | if (direction != DMA_TO_DEVICE) |
Olof Johansson | bc97ce9 | 2006-04-28 22:51:59 -0500 | [diff] [blame] | 58 | tce |= TCE_VB_WRITE; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 59 | } else { |
| 60 | /* PCI Bus */ |
Olof Johansson | bc97ce9 | 2006-04-28 22:51:59 -0500 | [diff] [blame] | 61 | tce |= TCE_PCI_READ; /* Read allowed */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 62 | if (direction != DMA_TO_DEVICE) |
Olof Johansson | bc97ce9 | 2006-04-28 22:51:59 -0500 | [diff] [blame] | 63 | tce |= TCE_PCI_WRITE; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 64 | } |
| 65 | |
Olof Johansson | bc97ce9 | 2006-04-28 22:51:59 -0500 | [diff] [blame] | 66 | rc = HvCallXm_setTce((u64)tbl->it_index, (u64)index, tce); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 67 | if (rc) |
| 68 | panic("PCI_DMA: HvCallXm_setTce failed, Rc: 0x%lx\n", |
| 69 | rc); |
| 70 | index++; |
Benjamin Herrenschmidt | 3c726f8 | 2005-11-07 11:06:55 +1100 | [diff] [blame] | 71 | uaddr += TCE_PAGE_SIZE; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 72 | } |
| 73 | } |
| 74 | |
| 75 | static 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 Herrenschmidt | 3c726f8 | 2005-11-07 11:06:55 +1100 | [diff] [blame] | 88 | /* |
Michael Ellerman | ca652c9 | 2006-07-14 14:25:33 +1000 | [diff] [blame] | 89 | * Structure passed to HvCallXm_getTceTableParms |
| 90 | */ |
| 91 | struct 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 Herrenschmidt | 3c726f8 | 2005-11-07 11:06:55 +1100 | [diff] [blame] | 106 | * 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 | */ |
| 114 | void 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 Burman | f848535 | 2006-12-02 13:26:57 +0200 | [diff] [blame] | 121 | parms = kzalloc(sizeof(*parms), GFP_KERNEL); |
Benjamin Herrenschmidt | 3c726f8 | 2005-11-07 11:06:55 +1100 | [diff] [blame] | 122 | if (parms == NULL) |
| 123 | panic("PCI_DMA: TCE Table Allocation failed."); |
| 124 | |
Benjamin Herrenschmidt | 3c726f8 | 2005-11-07 11:06:55 +1100 | [diff] [blame] | 125 | 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 Vepstas | 5d2efba | 2006-10-30 16:15:59 +1100 | [diff] [blame] | 135 | tbl->it_size = (parms->itc_size * TCE_PAGE_SIZE) / TCE_ENTRY_SIZE; |
Benjamin Herrenschmidt | 3c726f8 | 2005-11-07 11:06:55 +1100 | [diff] [blame] | 136 | tbl->it_busno = parms->itc_busno; |
Linas Vepstas | 5d2efba | 2006-10-30 16:15:59 +1100 | [diff] [blame] | 137 | tbl->it_offset = parms->itc_offset; |
Benjamin Herrenschmidt | 3c726f8 | 2005-11-07 11:06:55 +1100 | [diff] [blame] | 138 | 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 Rothwell | 145d01e | 2005-06-21 17:15:52 -0700 | [diff] [blame] | 146 | #ifdef CONFIG_PCI |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 147 | /* |
| 148 | * This function compares the known tables to find an iommu_table |
| 149 | * that has already been built for hardware TCEs. |
| 150 | */ |
| 151 | static struct iommu_table *iommu_table_find(struct iommu_table * tbl) |
| 152 | { |
Stephen Rothwell | 96ff6af | 2006-05-19 16:48:47 +1000 | [diff] [blame] | 153 | struct device_node *node; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 154 | |
Stephen Rothwell | 96ff6af | 2006-05-19 16:48:47 +1000 | [diff] [blame] | 155 | 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 Rothwell | 252e75a | 2005-09-28 14:40:40 +1000 | [diff] [blame] | 162 | if ((it != NULL) && |
| 163 | (it->it_type == TCE_PCI) && |
| 164 | (it->it_offset == tbl->it_offset) && |
| 165 | (it->it_index == tbl->it_index) && |
Julia Lawall | af449c3 | 2007-12-13 15:56:15 -0800 | [diff] [blame] | 166 | (it->it_size == tbl->it_size)) { |
| 167 | of_node_put(node); |
Stephen Rothwell | 252e75a | 2005-09-28 14:40:40 +1000 | [diff] [blame] | 168 | return it; |
Julia Lawall | af449c3 | 2007-12-13 15:56:15 -0800 | [diff] [blame] | 169 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 170 | } |
| 171 | return NULL; |
| 172 | } |
| 173 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 174 | |
Benjamin Herrenschmidt | 12d04ee | 2006-11-11 17:25:02 +1100 | [diff] [blame] | 175 | 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] | 176 | { |
| 177 | struct iommu_table *tbl; |
Stephen Rothwell | 252e75a | 2005-09-28 14:40:40 +1000 | [diff] [blame] | 178 | struct pci_dn *pdn = PCI_DN(dn); |
Stephen Rothwell | e2eb639 | 2007-04-03 22:26:41 +1000 | [diff] [blame] | 179 | const u32 *lsn = of_get_property(dn, "linux,logical-slot-number", NULL); |
Stephen Rothwell | 403fac4 | 2006-05-19 16:51:57 +1000 | [diff] [blame] | 180 | |
| 181 | BUG_ON(lsn == NULL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 182 | |
| 183 | tbl = kmalloc(sizeof(struct iommu_table), GFP_KERNEL); |
| 184 | |
Stephen Rothwell | 403fac4 | 2006-05-19 16:51:57 +1000 | [diff] [blame] | 185 | iommu_table_getparms_iSeries(pdn->busno, *lsn, 0, tbl); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 186 | |
| 187 | /* Look for existing tce table */ |
Stephen Rothwell | 252e75a | 2005-09-28 14:40:40 +1000 | [diff] [blame] | 188 | pdn->iommu_table = iommu_table_find(tbl); |
| 189 | if (pdn->iommu_table == NULL) |
Anton Blanchard | ca1588e | 2006-06-10 20:58:08 +1000 | [diff] [blame] | 190 | pdn->iommu_table = iommu_init_table(tbl, -1); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 191 | else |
| 192 | kfree(tbl); |
Benjamin Herrenschmidt | 12d04ee | 2006-11-11 17:25:02 +1100 | [diff] [blame] | 193 | pdev->dev.archdata.dma_data = pdn->iommu_table; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 194 | } |
Stephen Rothwell | 145d01e | 2005-06-21 17:15:52 -0700 | [diff] [blame] | 195 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 196 | |
Stephen Rothwell | dd9b67a | 2007-10-11 14:55:02 +1000 | [diff] [blame] | 197 | static struct iommu_table veth_iommu_table; |
| 198 | static struct iommu_table vio_iommu_table; |
Stephen Rothwell | 1670b2b | 2007-10-11 14:53:32 +1000 | [diff] [blame] | 199 | |
| 200 | void *iseries_hv_alloc(size_t size, dma_addr_t *dma_handle, gfp_t flag) |
| 201 | { |
| 202 | return iommu_alloc_coherent(&vio_iommu_table, size, dma_handle, |
| 203 | DMA_32BIT_MASK, flag, -1); |
| 204 | } |
| 205 | EXPORT_SYMBOL_GPL(iseries_hv_alloc); |
| 206 | |
| 207 | void iseries_hv_free(size_t size, void *vaddr, dma_addr_t dma_handle) |
| 208 | { |
| 209 | iommu_free_coherent(&vio_iommu_table, size, vaddr, dma_handle); |
| 210 | } |
| 211 | EXPORT_SYMBOL_GPL(iseries_hv_free); |
| 212 | |
| 213 | dma_addr_t iseries_hv_map(void *vaddr, size_t size, |
| 214 | enum dma_data_direction direction) |
| 215 | { |
| 216 | return iommu_map_single(&vio_iommu_table, vaddr, size, |
| 217 | DMA_32BIT_MASK, direction); |
| 218 | } |
| 219 | |
| 220 | void iseries_hv_unmap(dma_addr_t dma_handle, size_t size, |
| 221 | enum dma_data_direction direction) |
| 222 | { |
| 223 | iommu_unmap_single(&vio_iommu_table, dma_handle, size, direction); |
| 224 | } |
| 225 | |
Stephen Rothwell | dd9b67a | 2007-10-11 14:55:02 +1000 | [diff] [blame] | 226 | void __init iommu_vio_init(void) |
| 227 | { |
| 228 | iommu_table_getparms_iSeries(255, 0, 0xff, &veth_iommu_table); |
| 229 | veth_iommu_table.it_size /= 2; |
| 230 | vio_iommu_table = veth_iommu_table; |
| 231 | vio_iommu_table.it_offset += veth_iommu_table.it_size; |
| 232 | |
| 233 | if (!iommu_init_table(&veth_iommu_table, -1)) |
| 234 | printk("Virtual Bus VETH TCE table failed.\n"); |
| 235 | if (!iommu_init_table(&vio_iommu_table, -1)) |
| 236 | printk("Virtual Bus VIO TCE table failed.\n"); |
| 237 | } |
| 238 | |
| 239 | struct iommu_table *vio_build_iommu_table_iseries(struct vio_dev *dev) |
| 240 | { |
| 241 | if (strcmp(dev->type, "network") == 0) |
| 242 | return &veth_iommu_table; |
| 243 | return &vio_iommu_table; |
| 244 | } |
| 245 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 246 | void iommu_init_early_iSeries(void) |
| 247 | { |
| 248 | ppc_md.tce_build = tce_build_iSeries; |
| 249 | ppc_md.tce_free = tce_free_iSeries; |
| 250 | |
Stephen Rothwell | 9874777 | 2007-03-04 16:58:39 +1100 | [diff] [blame] | 251 | set_pci_dma_ops(&dma_iommu_ops); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 252 | } |