1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * OpenRISC Linux 4 * 5 * Linux architectural port borrowing liberally from similar works of 6 * others. All original copyrights apply as per the original source 7 * declaration. 8 * 9 * Modifications for the OpenRISC architecture: 10 * Copyright (C) 2003 Matjaz Breskvar <phoenix@bsemi.com> 11 * Copyright (C) 2010-2011 Jonas Bonn <jonas@southpole.se> 12 * 13 * DMA mapping callbacks... 14 */ 15 16 #include <linux/dma-noncoherent.h> 17 #include <linux/pagewalk.h> 18 19 #include <asm/cpuinfo.h> 20 #include <asm/spr_defs.h> 21 #include <asm/tlbflush.h> 22 23 static int 24 page_set_nocache(pte_t *pte, unsigned long addr, 25 unsigned long next, struct mm_walk *walk) 26 { 27 unsigned long cl; 28 struct cpuinfo_or1k *cpuinfo = &cpuinfo_or1k[smp_processor_id()]; 29 30 pte_val(*pte) |= _PAGE_CI; 31 32 /* 33 * Flush the page out of the TLB so that the new page flags get 34 * picked up next time there's an access 35 */ 36 flush_tlb_page(NULL, addr); 37 38 /* Flush page out of dcache */ 39 for (cl = __pa(addr); cl < __pa(next); cl += cpuinfo->dcache_block_size) 40 mtspr(SPR_DCBFR, cl); 41 42 return 0; 43 } 44 45 static const struct mm_walk_ops set_nocache_walk_ops = { 46 .pte_entry = page_set_nocache, 47 }; 48 49 static int 50 page_clear_nocache(pte_t *pte, unsigned long addr, 51 unsigned long next, struct mm_walk *walk) 52 { 53 pte_val(*pte) &= ~_PAGE_CI; 54 55 /* 56 * Flush the page out of the TLB so that the new page flags get 57 * picked up next time there's an access 58 */ 59 flush_tlb_page(NULL, addr); 60 61 return 0; 62 } 63 64 static const struct mm_walk_ops clear_nocache_walk_ops = { 65 .pte_entry = page_clear_nocache, 66 }; 67 68 void *arch_dma_set_uncached(void *cpu_addr, size_t size) 69 { 70 unsigned long va = (unsigned long)cpu_addr; 71 int error; 72 73 /* 74 * We need to iterate through the pages, clearing the dcache for 75 * them and setting the cache-inhibit bit. 76 */ 77 error = walk_page_range(&init_mm, va, va + size, &set_nocache_walk_ops, 78 NULL); 79 if (error) 80 return ERR_PTR(error); 81 return cpu_addr; 82 } 83 84 void arch_dma_clear_uncached(void *cpu_addr, size_t size) 85 { 86 unsigned long va = (unsigned long)cpu_addr; 87 88 /* walk_page_range shouldn't be able to fail here */ 89 WARN_ON(walk_page_range(&init_mm, va, va + size, 90 &clear_nocache_walk_ops, NULL)); 91 } 92 93 void arch_sync_dma_for_device(phys_addr_t addr, size_t size, 94 enum dma_data_direction dir) 95 { 96 unsigned long cl; 97 struct cpuinfo_or1k *cpuinfo = &cpuinfo_or1k[smp_processor_id()]; 98 99 switch (dir) { 100 case DMA_TO_DEVICE: 101 /* Flush the dcache for the requested range */ 102 for (cl = addr; cl < addr + size; 103 cl += cpuinfo->dcache_block_size) 104 mtspr(SPR_DCBFR, cl); 105 break; 106 case DMA_FROM_DEVICE: 107 /* Invalidate the dcache for the requested range */ 108 for (cl = addr; cl < addr + size; 109 cl += cpuinfo->dcache_block_size) 110 mtspr(SPR_DCBIR, cl); 111 break; 112 default: 113 /* 114 * NOTE: If dir == DMA_BIDIRECTIONAL then there's no need to 115 * flush nor invalidate the cache here as the area will need 116 * to be manually synced anyway. 117 */ 118 break; 119 } 120 } 121