1/* 2 * Device driver for the SYMBIOS/LSILOGIC 53C8XX and 53C1010 family 3 * of PCI-SCSI IO processors. 4 * 5 * Copyright (C) 1999-2001 Gerard Roudier <groudier@free.fr> 6 * 7 * This driver is derived from the Linux sym53c8xx driver. 8 * Copyright (C) 1998-2000 Gerard Roudier 9 * 10 * The sym53c8xx driver is derived from the ncr53c8xx driver that had been 11 * a port of the FreeBSD ncr driver to Linux-1.2.13. 12 * 13 * The original ncr driver has been written for 386bsd and FreeBSD by 14 * Wolfgang Stanglmeier <wolf@cologne.de> 15 * Stefan Esser <se@mi.Uni-Koeln.de> 16 * Copyright (C) 1994 Wolfgang Stanglmeier 17 * 18 * Other major contributions: 19 * 20 * NVRAM detection and reading. 21 * Copyright (C) 1997 Richard Waltham <dormouse@farsrobt.demon.co.uk> 22 * 23 *----------------------------------------------------------------------------- 24 * 25 * This program is free software; you can redistribute it and/or modify 26 * it under the terms of the GNU General Public License as published by 27 * the Free Software Foundation; either version 2 of the License, or 28 * (at your option) any later version. 29 * 30 * This program is distributed in the hope that it will be useful, 31 * but WITHOUT ANY WARRANTY; without even the implied warranty of 32 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 33 * GNU General Public License for more details. 34 * 35 * You should have received a copy of the GNU General Public License 36 * along with this program; if not, write to the Free Software 37 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 38 */ 39 40#include "sym_glue.h" 41 42/* 43 * Simple power of two buddy-like generic allocator. 44 * Provides naturally aligned memory chunks. 45 * 46 * This simple code is not intended to be fast, but to 47 * provide power of 2 aligned memory allocations. 48 * Since the SCRIPTS processor only supplies 8 bit arithmetic, 49 * this allocator allows simple and fast address calculations 50 * from the SCRIPTS code. In addition, cache line alignment 51 * is guaranteed for power of 2 cache line size. 52 * 53 * This allocator has been developped for the Linux sym53c8xx 54 * driver, since this O/S does not provide naturally aligned 55 * allocations. 56 * It has the advantage of allowing the driver to use private 57 * pages of memory that will be useful if we ever need to deal 58 * with IO MMUs for PCI. 59 */ 60static void *___sym_malloc(m_pool_p mp, int size) 61{ 62 int i = 0; 63 int s = (1 << SYM_MEM_SHIFT); 64 int j; 65 void *a; 66 m_link_p h = mp->h; 67 68 if (size > SYM_MEM_CLUSTER_SIZE) 69 return NULL; 70 71 while (size > s) { 72 s <<= 1; 73 ++i; 74 } 75 76 j = i; 77 while (!h[j].next) { 78 if (s == SYM_MEM_CLUSTER_SIZE) { 79 h[j].next = (m_link_p) M_GET_MEM_CLUSTER(); 80 if (h[j].next) 81 h[j].next->next = NULL; 82 break; 83 } 84 ++j; 85 s <<= 1; 86 } 87 a = h[j].next; 88 if (a) { 89 h[j].next = h[j].next->next; 90 while (j > i) { 91 j -= 1; 92 s >>= 1; 93 h[j].next = (m_link_p) (a+s); 94 h[j].next->next = NULL; 95 } 96 } 97#ifdef DEBUG 98 printf("___sym_malloc(%d) = %p\n", size, (void *) a); 99#endif 100 return a; 101} 102 103/* 104 * Counter-part of the generic allocator. 105 */ 106static void ___sym_mfree(m_pool_p mp, void *ptr, int size) 107{ 108 int i = 0; 109 int s = (1 << SYM_MEM_SHIFT); 110 m_link_p q; 111 unsigned long a, b; 112 m_link_p h = mp->h; 113 114#ifdef DEBUG 115 printf("___sym_mfree(%p, %d)\n", ptr, size); 116#endif 117 118 if (size > SYM_MEM_CLUSTER_SIZE) 119 return; 120 121 while (size > s) { 122 s <<= 1; 123 ++i; 124 } 125 126 a = (unsigned long)ptr; 127 128 while (1) { 129 if (s == SYM_MEM_CLUSTER_SIZE) { 130#ifdef SYM_MEM_FREE_UNUSED 131 M_FREE_MEM_CLUSTER((void *)a); 132#else 133 ((m_link_p) a)->next = h[i].next; 134 h[i].next = (m_link_p) a; 135#endif 136 break; 137 } 138 b = a ^ s; 139 q = &h[i]; 140 while (q->next && q->next != (m_link_p) b) { 141 q = q->next; 142 } 143 if (!q->next) { 144 ((m_link_p) a)->next = h[i].next; 145 h[i].next = (m_link_p) a; 146 break; 147 } 148 q->next = q->next->next; 149 a = a & b; 150 s <<= 1; 151 ++i; 152 } 153} 154 155/* 156 * Verbose and zeroing allocator that wrapps to the generic allocator. 157 */ 158static void *__sym_calloc2(m_pool_p mp, int size, char *name, int uflags) 159{ 160 void *p; 161 162 p = ___sym_malloc(mp, size); 163 164 if (DEBUG_FLAGS & DEBUG_ALLOC) { 165 printf ("new %-10s[%4d] @%p.\n", name, size, p); 166 } 167 168 if (p) 169 memset(p, 0, size); 170 else if (uflags & SYM_MEM_WARN) 171 printf ("__sym_calloc2: failed to allocate %s[%d]\n", name, size); 172 return p; 173} 174#define __sym_calloc(mp, s, n) __sym_calloc2(mp, s, n, SYM_MEM_WARN) 175 176/* 177 * Its counter-part. 178 */ 179static void __sym_mfree(m_pool_p mp, void *ptr, int size, char *name) 180{ 181 if (DEBUG_FLAGS & DEBUG_ALLOC) 182 printf ("freeing %-10s[%4d] @%p.\n", name, size, ptr); 183 184 ___sym_mfree(mp, ptr, size); 185} 186 187/* 188 * Default memory pool we donnot need to involve in DMA. 189 * 190 * With DMA abstraction, we use functions (methods), to 191 * distinguish between non DMAable memory and DMAable memory. 192 */ 193static void *___mp0_get_mem_cluster(m_pool_p mp) 194{ 195 void *m = sym_get_mem_cluster(); 196 if (m) 197 ++mp->nump; 198 return m; 199} 200 201#ifdef SYM_MEM_FREE_UNUSED 202static void ___mp0_free_mem_cluster(m_pool_p mp, void *m) 203{ 204 sym_free_mem_cluster(m); 205 --mp->nump; 206} 207#else 208#define ___mp0_free_mem_cluster NULL 209#endif 210 211static struct sym_m_pool mp0 = { 212 NULL, 213 ___mp0_get_mem_cluster, 214 ___mp0_free_mem_cluster 215}; 216 217/* 218 * Methods that maintains DMAable pools according to user allocations. 219 * New pools are created on the fly when a new pool id is provided. 220 * They are deleted on the fly when they get emptied. 221 */ 222/* Get a memory cluster that matches the DMA constraints of a given pool */ 223static void * ___get_dma_mem_cluster(m_pool_p mp) 224{ 225 m_vtob_p vbp; 226 void *vaddr; 227 228 vbp = __sym_calloc(&mp0, sizeof(*vbp), "VTOB"); 229 if (!vbp) 230 goto out_err; 231 232 vaddr = sym_m_get_dma_mem_cluster(mp, vbp); 233 if (vaddr) { 234 int hc = VTOB_HASH_CODE(vaddr); 235 vbp->next = mp->vtob[hc]; 236 mp->vtob[hc] = vbp; 237 ++mp->nump; 238 } 239 return vaddr; 240out_err: 241 return NULL; 242} 243 244#ifdef SYM_MEM_FREE_UNUSED 245/* Free a memory cluster and associated resources for DMA */ 246static void ___free_dma_mem_cluster(m_pool_p mp, void *m) 247{ 248 m_vtob_p *vbpp, vbp; 249 int hc = VTOB_HASH_CODE(m); 250 251 vbpp = &mp->vtob[hc]; 252 while (*vbpp && (*vbpp)->vaddr != m) 253 vbpp = &(*vbpp)->next; 254 if (*vbpp) { 255 vbp = *vbpp; 256 *vbpp = (*vbpp)->next; 257 sym_m_free_dma_mem_cluster(mp, vbp); 258 __sym_mfree(&mp0, vbp, sizeof(*vbp), "VTOB"); 259 --mp->nump; 260 } 261} 262#endif 263 264/* Fetch the memory pool for a given pool id (i.e. DMA constraints) */ 265static __inline m_pool_p ___get_dma_pool(m_pool_ident_t dev_dmat) 266{ 267 m_pool_p mp; 268 for (mp = mp0.next; 269 mp && !sym_m_pool_match(mp->dev_dmat, dev_dmat); 270 mp = mp->next); 271 return mp; 272} 273 274/* Create a new memory DMAable pool (when fetch failed) */ 275static m_pool_p ___cre_dma_pool(m_pool_ident_t dev_dmat) 276{ 277 m_pool_p mp = __sym_calloc(&mp0, sizeof(*mp), "MPOOL"); 278 if (mp) { 279 mp->dev_dmat = dev_dmat; 280 mp->get_mem_cluster = ___get_dma_mem_cluster; 281#ifdef SYM_MEM_FREE_UNUSED 282 mp->free_mem_cluster = ___free_dma_mem_cluster; 283#endif 284 mp->next = mp0.next; 285 mp0.next = mp; 286 return mp; 287 } 288 return NULL; 289} 290 291#ifdef SYM_MEM_FREE_UNUSED 292/* Destroy a DMAable memory pool (when got emptied) */ 293static void ___del_dma_pool(m_pool_p p) 294{ 295 m_pool_p *pp = &mp0.next; 296 297 while (*pp && *pp != p) 298 pp = &(*pp)->next; 299 if (*pp) { 300 *pp = (*pp)->next; 301 __sym_mfree(&mp0, p, sizeof(*p), "MPOOL"); 302 } 303} 304#endif 305 306/* This lock protects only the memory allocation/free. */ 307static DEFINE_SPINLOCK(sym53c8xx_lock); 308 309/* 310 * Actual allocator for DMAable memory. 311 */ 312void *__sym_calloc_dma(m_pool_ident_t dev_dmat, int size, char *name) 313{ 314 unsigned long flags; 315 m_pool_p mp; 316 void *m = NULL; 317 318 spin_lock_irqsave(&sym53c8xx_lock, flags); 319 mp = ___get_dma_pool(dev_dmat); 320 if (!mp) 321 mp = ___cre_dma_pool(dev_dmat); 322 if (!mp) 323 goto out; 324 m = __sym_calloc(mp, size, name); 325#ifdef SYM_MEM_FREE_UNUSED 326 if (!mp->nump) 327 ___del_dma_pool(mp); 328#endif 329 330 out: 331 spin_unlock_irqrestore(&sym53c8xx_lock, flags); 332 return m; 333} 334 335void __sym_mfree_dma(m_pool_ident_t dev_dmat, void *m, int size, char *name) 336{ 337 unsigned long flags; 338 m_pool_p mp; 339 340 spin_lock_irqsave(&sym53c8xx_lock, flags); 341 mp = ___get_dma_pool(dev_dmat); 342 if (!mp) 343 goto out; 344 __sym_mfree(mp, m, size, name); 345#ifdef SYM_MEM_FREE_UNUSED 346 if (!mp->nump) 347 ___del_dma_pool(mp); 348#endif 349 out: 350 spin_unlock_irqrestore(&sym53c8xx_lock, flags); 351} 352 353/* 354 * Actual virtual to bus physical address translator 355 * for 32 bit addressable DMAable memory. 356 */ 357dma_addr_t __vtobus(m_pool_ident_t dev_dmat, void *m) 358{ 359 unsigned long flags; 360 m_pool_p mp; 361 int hc = VTOB_HASH_CODE(m); 362 m_vtob_p vp = NULL; 363 void *a = (void *)((unsigned long)m & ~SYM_MEM_CLUSTER_MASK); 364 dma_addr_t b; 365 366 spin_lock_irqsave(&sym53c8xx_lock, flags); 367 mp = ___get_dma_pool(dev_dmat); 368 if (mp) { 369 vp = mp->vtob[hc]; 370 while (vp && vp->vaddr != a) 371 vp = vp->next; 372 } 373 if (!vp) 374 panic("sym: VTOBUS FAILED!\n"); 375 b = vp->baddr + (m - a); 376 spin_unlock_irqrestore(&sym53c8xx_lock, flags); 377 return b; 378} 379