Greg Kroah-Hartman | b244131 | 2017-11-01 15:07:57 +0100 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0 |
Adrian Bunk | 88278ca | 2008-05-19 16:53:02 -0700 | [diff] [blame] | 2 | /* |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 3 | * io-unit.c: IO-UNIT specific routines for memory management. |
| 4 | * |
| 5 | * Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz) |
| 6 | */ |
| 7 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 8 | #include <linux/kernel.h> |
| 9 | #include <linux/init.h> |
| 10 | #include <linux/slab.h> |
| 11 | #include <linux/spinlock.h> |
| 12 | #include <linux/mm.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 13 | #include <linux/bitops.h> |
Christoph Hellwig | 0a0f0d8 | 2020-09-22 15:31:03 +0200 | [diff] [blame] | 14 | #include <linux/dma-map-ops.h> |
David S. Miller | 9dc6923 | 2008-08-27 19:54:01 -0700 | [diff] [blame] | 15 | #include <linux/of.h> |
Rob Herring | 263291f | 2023-07-18 14:45:20 -0600 | [diff] [blame] | 16 | #include <linux/of_platform.h> |
| 17 | #include <linux/platform_device.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 18 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 19 | #include <asm/io.h> |
| 20 | #include <asm/io-unit.h> |
| 21 | #include <asm/mxcc.h> |
| 22 | #include <asm/cacheflush.h> |
| 23 | #include <asm/tlbflush.h> |
| 24 | #include <asm/dma.h> |
David S. Miller | d4accd6 | 2006-11-30 17:11:26 -0800 | [diff] [blame] | 25 | #include <asm/oplib.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 26 | |
Sam Ravnborg | 1918660 | 2014-05-16 23:25:41 +0200 | [diff] [blame] | 27 | #include "mm_32.h" |
| 28 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 29 | /* #define IOUNIT_DEBUG */ |
| 30 | #ifdef IOUNIT_DEBUG |
| 31 | #define IOD(x) printk(x) |
| 32 | #else |
| 33 | #define IOD(x) do { } while (0) |
| 34 | #endif |
| 35 | |
| 36 | #define IOPERM (IOUPTE_CACHE | IOUPTE_WRITE | IOUPTE_VALID) |
| 37 | #define MKIOPTE(phys) __iopte((((phys)>>4) & IOUPTE_PAGE) | IOPERM) |
| 38 | |
Christoph Hellwig | 255a69a | 2020-03-23 09:43:42 +0100 | [diff] [blame] | 39 | static const struct dma_map_ops iounit_dma_ops; |
| 40 | |
Grant Likely | cd4cd73 | 2010-07-22 16:04:30 -0600 | [diff] [blame] | 41 | static void __init iounit_iommu_init(struct platform_device *op) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 42 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 43 | struct iounit_struct *iounit; |
Sam Ravnborg | 1918660 | 2014-05-16 23:25:41 +0200 | [diff] [blame] | 44 | iopte_t __iomem *xpt; |
| 45 | iopte_t __iomem *xptend; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 46 | |
Yan Burman | c80892d | 2006-11-30 17:07:04 -0800 | [diff] [blame] | 47 | iounit = kzalloc(sizeof(struct iounit_struct), GFP_ATOMIC); |
David S. Miller | d4accd6 | 2006-11-30 17:11:26 -0800 | [diff] [blame] | 48 | if (!iounit) { |
| 49 | prom_printf("SUN4D: Cannot alloc iounit, halting.\n"); |
| 50 | prom_halt(); |
| 51 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 52 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 53 | iounit->limit[0] = IOUNIT_BMAP1_START; |
| 54 | iounit->limit[1] = IOUNIT_BMAP2_START; |
| 55 | iounit->limit[2] = IOUNIT_BMAPM_START; |
| 56 | iounit->limit[3] = IOUNIT_BMAPM_END; |
| 57 | iounit->rotor[1] = IOUNIT_BMAP2_START; |
| 58 | iounit->rotor[2] = IOUNIT_BMAPM_START; |
| 59 | |
David S. Miller | e003934 | 2008-08-25 22:47:20 -0700 | [diff] [blame] | 60 | xpt = of_ioremap(&op->resource[2], 0, PAGE_SIZE * 16, "XPT"); |
| 61 | if (!xpt) { |
| 62 | prom_printf("SUN4D: Cannot map External Page Table."); |
| 63 | prom_halt(); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 64 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 65 | |
David S. Miller | e003934 | 2008-08-25 22:47:20 -0700 | [diff] [blame] | 66 | op->dev.archdata.iommu = iounit; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 67 | iounit->page_table = xpt; |
Raymond Burns | 2f72ba4 | 2006-07-17 21:40:27 -0700 | [diff] [blame] | 68 | spin_lock_init(&iounit->lock); |
Sam Ravnborg | 1918660 | 2014-05-16 23:25:41 +0200 | [diff] [blame] | 69 | |
| 70 | xptend = iounit->page_table + (16 * PAGE_SIZE) / sizeof(iopte_t); |
| 71 | for (; xpt < xptend; xpt++) |
| 72 | sbus_writel(0, xpt); |
Christoph Hellwig | 255a69a | 2020-03-23 09:43:42 +0100 | [diff] [blame] | 73 | |
| 74 | op->dev.dma_ops = &iounit_dma_ops; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 75 | } |
| 76 | |
David S. Miller | 046e26a | 2008-08-27 04:54:04 -0700 | [diff] [blame] | 77 | static int __init iounit_init(void) |
| 78 | { |
| 79 | extern void sun4d_init_sbi_irq(void); |
| 80 | struct device_node *dp; |
| 81 | |
| 82 | for_each_node_by_name(dp, "sbi") { |
Grant Likely | cd4cd73 | 2010-07-22 16:04:30 -0600 | [diff] [blame] | 83 | struct platform_device *op = of_find_device_by_node(dp); |
David S. Miller | 046e26a | 2008-08-27 04:54:04 -0700 | [diff] [blame] | 84 | |
| 85 | iounit_iommu_init(op); |
| 86 | of_propagate_archdata(op); |
| 87 | } |
| 88 | |
| 89 | sun4d_init_sbi_irq(); |
| 90 | |
| 91 | return 0; |
| 92 | } |
| 93 | |
| 94 | subsys_initcall(iounit_init); |
| 95 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 96 | /* One has to hold iounit->lock to call this */ |
| 97 | static unsigned long iounit_get_area(struct iounit_struct *iounit, unsigned long vaddr, int size) |
| 98 | { |
| 99 | int i, j, k, npages; |
| 100 | unsigned long rotor, scan, limit; |
| 101 | iopte_t iopte; |
| 102 | |
| 103 | npages = ((vaddr & ~PAGE_MASK) + size + (PAGE_SIZE-1)) >> PAGE_SHIFT; |
| 104 | |
| 105 | /* A tiny bit of magic ingredience :) */ |
| 106 | switch (npages) { |
| 107 | case 1: i = 0x0231; break; |
| 108 | case 2: i = 0x0132; break; |
| 109 | default: i = 0x0213; break; |
| 110 | } |
| 111 | |
| 112 | IOD(("iounit_get_area(%08lx,%d[%d])=", vaddr, size, npages)); |
| 113 | |
| 114 | next: j = (i & 15); |
| 115 | rotor = iounit->rotor[j - 1]; |
| 116 | limit = iounit->limit[j]; |
| 117 | scan = rotor; |
| 118 | nexti: scan = find_next_zero_bit(iounit->bmap, limit, scan); |
| 119 | if (scan + npages > limit) { |
| 120 | if (limit != rotor) { |
| 121 | limit = rotor; |
| 122 | scan = iounit->limit[j - 1]; |
| 123 | goto nexti; |
| 124 | } |
| 125 | i >>= 4; |
| 126 | if (!(i & 15)) |
| 127 | panic("iounit_get_area: Couldn't find free iopte slots for (%08lx,%d)\n", vaddr, size); |
| 128 | goto next; |
| 129 | } |
| 130 | for (k = 1, scan++; k < npages; k++) |
| 131 | if (test_bit(scan++, iounit->bmap)) |
| 132 | goto nexti; |
| 133 | iounit->rotor[j - 1] = (scan < limit) ? scan : iounit->limit[j - 1]; |
| 134 | scan -= npages; |
| 135 | iopte = MKIOPTE(__pa(vaddr & PAGE_MASK)); |
| 136 | vaddr = IOUNIT_DMA_BASE + (scan << PAGE_SHIFT) + (vaddr & ~PAGE_MASK); |
| 137 | for (k = 0; k < npages; k++, iopte = __iopte(iopte_val(iopte) + 0x100), scan++) { |
| 138 | set_bit(scan, iounit->bmap); |
Sam Ravnborg | 6e6e418 | 2016-04-22 19:41:06 +0200 | [diff] [blame] | 139 | sbus_writel(iopte_val(iopte), &iounit->page_table[scan]); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 140 | } |
| 141 | IOD(("%08lx\n", vaddr)); |
| 142 | return vaddr; |
| 143 | } |
| 144 | |
Christoph Hellwig | ce65d36 | 2018-12-03 14:04:32 +0100 | [diff] [blame] | 145 | static dma_addr_t iounit_map_page(struct device *dev, struct page *page, |
| 146 | unsigned long offset, size_t len, enum dma_data_direction dir, |
| 147 | unsigned long attrs) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 148 | { |
Christoph Hellwig | ce65d36 | 2018-12-03 14:04:32 +0100 | [diff] [blame] | 149 | void *vaddr = page_address(page) + offset; |
David S. Miller | 260489f | 2008-08-26 23:00:58 -0700 | [diff] [blame] | 150 | struct iounit_struct *iounit = dev->archdata.iommu; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 151 | unsigned long ret, flags; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 152 | |
Christoph Hellwig | ce65d36 | 2018-12-03 14:04:32 +0100 | [diff] [blame] | 153 | /* XXX So what is maxphys for us and how do drivers know it? */ |
| 154 | if (!len || len > 256 * 1024) |
| 155 | return DMA_MAPPING_ERROR; |
| 156 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 157 | spin_lock_irqsave(&iounit->lock, flags); |
| 158 | ret = iounit_get_area(iounit, (unsigned long)vaddr, len); |
| 159 | spin_unlock_irqrestore(&iounit->lock, flags); |
| 160 | return ret; |
| 161 | } |
| 162 | |
Christoph Hellwig | 1e2934a | 2018-12-16 10:20:04 +0100 | [diff] [blame] | 163 | static int iounit_map_sg(struct device *dev, struct scatterlist *sgl, int nents, |
Christoph Hellwig | ce65d36 | 2018-12-03 14:04:32 +0100 | [diff] [blame] | 164 | enum dma_data_direction dir, unsigned long attrs) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 165 | { |
David S. Miller | 260489f | 2008-08-26 23:00:58 -0700 | [diff] [blame] | 166 | struct iounit_struct *iounit = dev->archdata.iommu; |
Christoph Hellwig | 1e2934a | 2018-12-16 10:20:04 +0100 | [diff] [blame] | 167 | struct scatterlist *sg; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 168 | unsigned long flags; |
Christoph Hellwig | 1e2934a | 2018-12-16 10:20:04 +0100 | [diff] [blame] | 169 | int i; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 170 | |
| 171 | /* FIXME: Cache some resolved pages - often several sg entries are to the same page */ |
| 172 | spin_lock_irqsave(&iounit->lock, flags); |
Christoph Hellwig | 1e2934a | 2018-12-16 10:20:04 +0100 | [diff] [blame] | 173 | for_each_sg(sgl, sg, nents, i) { |
Robert Reif | aa83a26 | 2008-12-11 20:24:58 -0800 | [diff] [blame] | 174 | sg->dma_address = iounit_get_area(iounit, (unsigned long) sg_virt(sg), sg->length); |
| 175 | sg->dma_length = sg->length; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 176 | } |
| 177 | spin_unlock_irqrestore(&iounit->lock, flags); |
Christoph Hellwig | 1e2934a | 2018-12-16 10:20:04 +0100 | [diff] [blame] | 178 | return nents; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 179 | } |
| 180 | |
Christoph Hellwig | ce65d36 | 2018-12-03 14:04:32 +0100 | [diff] [blame] | 181 | static void iounit_unmap_page(struct device *dev, dma_addr_t vaddr, size_t len, |
| 182 | enum dma_data_direction dir, unsigned long attrs) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 183 | { |
David S. Miller | 260489f | 2008-08-26 23:00:58 -0700 | [diff] [blame] | 184 | struct iounit_struct *iounit = dev->archdata.iommu; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 185 | unsigned long flags; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 186 | |
| 187 | spin_lock_irqsave(&iounit->lock, flags); |
| 188 | len = ((vaddr & ~PAGE_MASK) + len + (PAGE_SIZE-1)) >> PAGE_SHIFT; |
| 189 | vaddr = (vaddr - IOUNIT_DMA_BASE) >> PAGE_SHIFT; |
| 190 | IOD(("iounit_release %08lx-%08lx\n", (long)vaddr, (long)len+vaddr)); |
| 191 | for (len += vaddr; vaddr < len; vaddr++) |
| 192 | clear_bit(vaddr, iounit->bmap); |
| 193 | spin_unlock_irqrestore(&iounit->lock, flags); |
| 194 | } |
| 195 | |
Christoph Hellwig | 1e2934a | 2018-12-16 10:20:04 +0100 | [diff] [blame] | 196 | static void iounit_unmap_sg(struct device *dev, struct scatterlist *sgl, |
| 197 | int nents, enum dma_data_direction dir, unsigned long attrs) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 198 | { |
David S. Miller | 260489f | 2008-08-26 23:00:58 -0700 | [diff] [blame] | 199 | struct iounit_struct *iounit = dev->archdata.iommu; |
Christoph Hellwig | 1e2934a | 2018-12-16 10:20:04 +0100 | [diff] [blame] | 200 | unsigned long flags, vaddr, len; |
| 201 | struct scatterlist *sg; |
| 202 | int i; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 203 | |
| 204 | spin_lock_irqsave(&iounit->lock, flags); |
Christoph Hellwig | 1e2934a | 2018-12-16 10:20:04 +0100 | [diff] [blame] | 205 | for_each_sg(sgl, sg, nents, i) { |
Robert Reif | aa83a26 | 2008-12-11 20:24:58 -0800 | [diff] [blame] | 206 | len = ((sg->dma_address & ~PAGE_MASK) + sg->length + (PAGE_SIZE-1)) >> PAGE_SHIFT; |
| 207 | vaddr = (sg->dma_address - IOUNIT_DMA_BASE) >> PAGE_SHIFT; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 208 | IOD(("iounit_release %08lx-%08lx\n", (long)vaddr, (long)len+vaddr)); |
| 209 | for (len += vaddr; vaddr < len; vaddr++) |
| 210 | clear_bit(vaddr, iounit->bmap); |
| 211 | } |
| 212 | spin_unlock_irqrestore(&iounit->lock, flags); |
| 213 | } |
| 214 | |
| 215 | #ifdef CONFIG_SBUS |
Christoph Hellwig | ce65d36 | 2018-12-03 14:04:32 +0100 | [diff] [blame] | 216 | static void *iounit_alloc(struct device *dev, size_t len, |
| 217 | dma_addr_t *dma_handle, gfp_t gfp, unsigned long attrs) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 218 | { |
David S. Miller | 4b1c5df | 2008-08-27 18:40:38 -0700 | [diff] [blame] | 219 | struct iounit_struct *iounit = dev->archdata.iommu; |
Christoph Hellwig | ce65d36 | 2018-12-03 14:04:32 +0100 | [diff] [blame] | 220 | unsigned long va, addr, page, end, ret; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 221 | pgprot_t dvma_prot; |
Sam Ravnborg | 1918660 | 2014-05-16 23:25:41 +0200 | [diff] [blame] | 222 | iopte_t __iomem *iopte; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 223 | |
Christoph Hellwig | ce65d36 | 2018-12-03 14:04:32 +0100 | [diff] [blame] | 224 | /* XXX So what is maxphys for us and how do drivers know it? */ |
| 225 | if (!len || len > 256 * 1024) |
| 226 | return NULL; |
| 227 | |
| 228 | len = PAGE_ALIGN(len); |
Christoph Hellwig | 518a2f1 | 2018-12-14 09:00:40 +0100 | [diff] [blame] | 229 | va = __get_free_pages(gfp | __GFP_ZERO, get_order(len)); |
Christoph Hellwig | ce65d36 | 2018-12-03 14:04:32 +0100 | [diff] [blame] | 230 | if (!va) |
| 231 | return NULL; |
| 232 | |
| 233 | addr = ret = sparc_dma_alloc_resource(dev, len); |
| 234 | if (!addr) |
| 235 | goto out_free_pages; |
| 236 | *dma_handle = addr; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 237 | |
| 238 | dvma_prot = __pgprot(SRMMU_CACHE | SRMMU_ET_PTE | SRMMU_PRIV); |
| 239 | end = PAGE_ALIGN((addr + len)); |
| 240 | while(addr < end) { |
| 241 | page = va; |
| 242 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 243 | pmd_t *pmdp; |
| 244 | pte_t *ptep; |
| 245 | long i; |
| 246 | |
Mike Rapoport | e05c7b1 | 2020-06-08 21:33:05 -0700 | [diff] [blame] | 247 | pmdp = pmd_off_k(addr); |
Hugh Dickins | 7a19c36 | 2023-06-08 12:33:40 -0700 | [diff] [blame] | 248 | ptep = pte_offset_kernel(pmdp, addr); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 249 | |
| 250 | set_pte(ptep, mk_pte(virt_to_page(page), dvma_prot)); |
Mike Rapoport | e05c7b1 | 2020-06-08 21:33:05 -0700 | [diff] [blame] | 251 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 252 | i = ((addr - IOUNIT_DMA_BASE) >> PAGE_SHIFT); |
| 253 | |
Sam Ravnborg | 1918660 | 2014-05-16 23:25:41 +0200 | [diff] [blame] | 254 | iopte = iounit->page_table + i; |
Sam Ravnborg | 6e6e418 | 2016-04-22 19:41:06 +0200 | [diff] [blame] | 255 | sbus_writel(iopte_val(MKIOPTE(__pa(page))), iopte); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 256 | } |
| 257 | addr += PAGE_SIZE; |
| 258 | va += PAGE_SIZE; |
| 259 | } |
| 260 | flush_cache_all(); |
| 261 | flush_tlb_all(); |
| 262 | |
Christoph Hellwig | ce65d36 | 2018-12-03 14:04:32 +0100 | [diff] [blame] | 263 | return (void *)ret; |
| 264 | |
| 265 | out_free_pages: |
| 266 | free_pages(va, get_order(len)); |
| 267 | return NULL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 268 | } |
| 269 | |
Christoph Hellwig | ce65d36 | 2018-12-03 14:04:32 +0100 | [diff] [blame] | 270 | static void iounit_free(struct device *dev, size_t size, void *cpu_addr, |
| 271 | dma_addr_t dma_addr, unsigned long attrs) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 272 | { |
| 273 | /* XXX Somebody please fill this in */ |
| 274 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 275 | #endif |
| 276 | |
Christoph Hellwig | ce65d36 | 2018-12-03 14:04:32 +0100 | [diff] [blame] | 277 | static const struct dma_map_ops iounit_dma_ops = { |
David S. Miller | d894d96 | 2012-05-13 13:57:05 -0700 | [diff] [blame] | 278 | #ifdef CONFIG_SBUS |
Christoph Hellwig | ce65d36 | 2018-12-03 14:04:32 +0100 | [diff] [blame] | 279 | .alloc = iounit_alloc, |
| 280 | .free = iounit_free, |
David S. Miller | d894d96 | 2012-05-13 13:57:05 -0700 | [diff] [blame] | 281 | #endif |
Christoph Hellwig | ce65d36 | 2018-12-03 14:04:32 +0100 | [diff] [blame] | 282 | .map_page = iounit_map_page, |
| 283 | .unmap_page = iounit_unmap_page, |
| 284 | .map_sg = iounit_map_sg, |
| 285 | .unmap_sg = iounit_unmap_sg, |
David S. Miller | d894d96 | 2012-05-13 13:57:05 -0700 | [diff] [blame] | 286 | }; |