1 /* 2 * Common CPM code 3 * 4 * Author: Scott Wood <scottwood@freescale.com> 5 * 6 * Copyright 2007-2008,2010 Freescale Semiconductor, Inc. 7 * 8 * Some parts derived from commproc.c/cpm2_common.c, which is: 9 * Copyright (c) 1997 Dan error_act (dmalek@jlc.net) 10 * Copyright (c) 1999-2001 Dan Malek <dan@embeddedalley.com> 11 * Copyright (c) 2000 MontaVista Software, Inc (source@mvista.com) 12 * 2006 (c) MontaVista Software, Inc. 13 * Vitaly Bordug <vbordug@ru.mvista.com> 14 * 15 * This program is free software; you can redistribute it and/or modify 16 * it under the terms of version 2 of the GNU General Public License as 17 * published by the Free Software Foundation. 18 */ 19 #include <linux/genalloc.h> 20 #include <linux/init.h> 21 #include <linux/list.h> 22 #include <linux/of_device.h> 23 #include <linux/spinlock.h> 24 #include <linux/export.h> 25 #include <linux/of.h> 26 #include <linux/of_address.h> 27 #include <linux/slab.h> 28 #include <linux/io.h> 29 #include <soc/fsl/qe/qe.h> 30 31 static struct gen_pool *muram_pool; 32 static spinlock_t cpm_muram_lock; 33 static u8 __iomem *muram_vbase; 34 static phys_addr_t muram_pbase; 35 36 struct muram_block { 37 struct list_head head; 38 unsigned long start; 39 int size; 40 }; 41 42 static LIST_HEAD(muram_block_list); 43 44 /* max address size we deal with */ 45 #define OF_MAX_ADDR_CELLS 4 46 #define GENPOOL_OFFSET (4096 * 8) 47 48 int cpm_muram_init(void) 49 { 50 struct device_node *np; 51 struct resource r; 52 u32 zero[OF_MAX_ADDR_CELLS] = {}; 53 resource_size_t max = 0; 54 int i = 0; 55 int ret = 0; 56 57 if (muram_pbase) 58 return 0; 59 60 spin_lock_init(&cpm_muram_lock); 61 np = of_find_compatible_node(NULL, NULL, "fsl,cpm-muram-data"); 62 if (!np) { 63 /* try legacy bindings */ 64 np = of_find_node_by_name(NULL, "data-only"); 65 if (!np) { 66 pr_err("Cannot find CPM muram data node"); 67 ret = -ENODEV; 68 goto out_muram; 69 } 70 } 71 72 muram_pool = gen_pool_create(0, -1); 73 if (!muram_pool) { 74 pr_err("Cannot allocate memory pool for CPM/QE muram"); 75 ret = -ENOMEM; 76 goto out_muram; 77 } 78 muram_pbase = of_translate_address(np, zero); 79 if (muram_pbase == (phys_addr_t)OF_BAD_ADDR) { 80 pr_err("Cannot translate zero through CPM muram node"); 81 ret = -ENODEV; 82 goto out_pool; 83 } 84 85 while (of_address_to_resource(np, i++, &r) == 0) { 86 if (r.end > max) 87 max = r.end; 88 ret = gen_pool_add(muram_pool, r.start - muram_pbase + 89 GENPOOL_OFFSET, resource_size(&r), -1); 90 if (ret) { 91 pr_err("QE: couldn't add muram to pool!\n"); 92 goto out_pool; 93 } 94 } 95 96 muram_vbase = ioremap(muram_pbase, max - muram_pbase + 1); 97 if (!muram_vbase) { 98 pr_err("Cannot map QE muram"); 99 ret = -ENOMEM; 100 goto out_pool; 101 } 102 goto out_muram; 103 out_pool: 104 gen_pool_destroy(muram_pool); 105 out_muram: 106 of_node_put(np); 107 return ret; 108 } 109 110 /* 111 * cpm_muram_alloc_common - cpm_muram_alloc common code 112 * @size: number of bytes to allocate 113 * @algo: algorithm for alloc. 114 * @data: data for genalloc's algorithm. 115 * 116 * This function returns an offset into the muram area. 117 */ 118 static unsigned long cpm_muram_alloc_common(unsigned long size, 119 genpool_algo_t algo, void *data) 120 { 121 struct muram_block *entry; 122 unsigned long start; 123 124 if (!muram_pool && cpm_muram_init()) 125 goto out2; 126 127 start = gen_pool_alloc_algo(muram_pool, size, algo, data); 128 if (!start) 129 goto out2; 130 start = start - GENPOOL_OFFSET; 131 memset_io(cpm_muram_addr(start), 0, size); 132 entry = kmalloc(sizeof(*entry), GFP_ATOMIC); 133 if (!entry) 134 goto out1; 135 entry->start = start; 136 entry->size = size; 137 list_add(&entry->head, &muram_block_list); 138 139 return start; 140 out1: 141 gen_pool_free(muram_pool, start, size); 142 out2: 143 return (unsigned long)-ENOMEM; 144 } 145 146 /* 147 * cpm_muram_alloc - allocate the requested size worth of multi-user ram 148 * @size: number of bytes to allocate 149 * @align: requested alignment, in bytes 150 * 151 * This function returns an offset into the muram area. 152 * Use cpm_dpram_addr() to get the virtual address of the area. 153 * Use cpm_muram_free() to free the allocation. 154 */ 155 unsigned long cpm_muram_alloc(unsigned long size, unsigned long align) 156 { 157 unsigned long start; 158 unsigned long flags; 159 struct genpool_data_align muram_pool_data; 160 161 spin_lock_irqsave(&cpm_muram_lock, flags); 162 muram_pool_data.align = align; 163 start = cpm_muram_alloc_common(size, gen_pool_first_fit_align, 164 &muram_pool_data); 165 spin_unlock_irqrestore(&cpm_muram_lock, flags); 166 return start; 167 } 168 EXPORT_SYMBOL(cpm_muram_alloc); 169 170 /** 171 * cpm_muram_free - free a chunk of multi-user ram 172 * @offset: The beginning of the chunk as returned by cpm_muram_alloc(). 173 */ 174 int cpm_muram_free(unsigned long offset) 175 { 176 unsigned long flags; 177 int size; 178 struct muram_block *tmp; 179 180 size = 0; 181 spin_lock_irqsave(&cpm_muram_lock, flags); 182 list_for_each_entry(tmp, &muram_block_list, head) { 183 if (tmp->start == offset) { 184 size = tmp->size; 185 list_del(&tmp->head); 186 kfree(tmp); 187 break; 188 } 189 } 190 gen_pool_free(muram_pool, offset + GENPOOL_OFFSET, size); 191 spin_unlock_irqrestore(&cpm_muram_lock, flags); 192 return size; 193 } 194 EXPORT_SYMBOL(cpm_muram_free); 195 196 /* 197 * cpm_muram_alloc_fixed - reserve a specific region of multi-user ram 198 * @offset: offset of allocation start address 199 * @size: number of bytes to allocate 200 * This function returns an offset into the muram area 201 * Use cpm_dpram_addr() to get the virtual address of the area. 202 * Use cpm_muram_free() to free the allocation. 203 */ 204 unsigned long cpm_muram_alloc_fixed(unsigned long offset, unsigned long size) 205 { 206 unsigned long start; 207 unsigned long flags; 208 struct genpool_data_fixed muram_pool_data_fixed; 209 210 spin_lock_irqsave(&cpm_muram_lock, flags); 211 muram_pool_data_fixed.offset = offset + GENPOOL_OFFSET; 212 start = cpm_muram_alloc_common(size, gen_pool_fixed_alloc, 213 &muram_pool_data_fixed); 214 spin_unlock_irqrestore(&cpm_muram_lock, flags); 215 return start; 216 } 217 EXPORT_SYMBOL(cpm_muram_alloc_fixed); 218 219 /** 220 * cpm_muram_addr - turn a muram offset into a virtual address 221 * @offset: muram offset to convert 222 */ 223 void __iomem *cpm_muram_addr(unsigned long offset) 224 { 225 return muram_vbase + offset; 226 } 227 EXPORT_SYMBOL(cpm_muram_addr); 228 229 unsigned long cpm_muram_offset(void __iomem *addr) 230 { 231 return addr - (void __iomem *)muram_vbase; 232 } 233 EXPORT_SYMBOL(cpm_muram_offset); 234 235 /** 236 * cpm_muram_dma - turn a muram virtual address into a DMA address 237 * @offset: virtual address from cpm_muram_addr() to convert 238 */ 239 dma_addr_t cpm_muram_dma(void __iomem *addr) 240 { 241 return muram_pbase + ((u8 __iomem *)addr - muram_vbase); 242 } 243 EXPORT_SYMBOL(cpm_muram_dma); 244