// SPDX-License-Identifier: GPL-2.0-or-later /* * Device driver for the SYMBIOS/LSILOGIC 53C8XX and 53C1010 family * of PCI-SCSI IO processors. * * Copyright (C) 1999-2001 Gerard Roudier <groudier@free.fr> * * This driver is derived from the Linux sym53c8xx driver. * Copyright (C) 1998-2000 Gerard Roudier * * The sym53c8xx driver is derived from the ncr53c8xx driver that had been * a port of the FreeBSD ncr driver to Linux-1.2.13. * * The original ncr driver has been written for 386bsd and FreeBSD by * Wolfgang Stanglmeier <wolf@cologne.de> * Stefan Esser <se@mi.Uni-Koeln.de> * Copyright (C) 1994 Wolfgang Stanglmeier * * Other major contributions: * * NVRAM detection and reading. * Copyright (C) 1997 Richard Waltham <dormouse@farsrobt.demon.co.uk> * *----------------------------------------------------------------------------- */ #include "sym_glue.h" /* * Simple power of two buddy-like generic allocator. * Provides naturally aligned memory chunks. * * This simple code is not intended to be fast, but to * provide power of 2 aligned memory allocations. * Since the SCRIPTS processor only supplies 8 bit arithmetic, * this allocator allows simple and fast address calculations * from the SCRIPTS code. In addition, cache line alignment * is guaranteed for power of 2 cache line size. * * This allocator has been developed for the Linux sym53c8xx * driver, since this O/S does not provide naturally aligned * allocations. * It has the advantage of allowing the driver to use private * pages of memory that will be useful if we ever need to deal * with IO MMUs for PCI. */ static void *___sym_malloc(m_pool_p mp, int size) { int i = 0; int s = (1 << SYM_MEM_SHIFT); int j; void *a; m_link_p h = mp->h; if (size > SYM_MEM_CLUSTER_SIZE) return NULL; while (size > s) { s <<= 1; ++i; } j = i; while (!h[j].next) { if (s == SYM_MEM_CLUSTER_SIZE) { h[j].next = (m_link_p) M_GET_MEM_CLUSTER(); if (h[j].next) h[j].next->next = NULL; break; } ++j; s <<= 1; } a = h[j].next; if (a) { h[j].next = h[j].next->next; while (j > i) { j -= 1; s >>= 1; h[j].next = (m_link_p) (a+s); h[j].next->next = NULL; } } #ifdef DEBUG printf("___sym_malloc(%d) = %p\n", size, (void *) a); #endif return a; } /* * Counter-part of the generic allocator. */ static void ___sym_mfree(m_pool_p mp, void *ptr, int size) { int i = 0; int s = (1 << SYM_MEM_SHIFT); m_link_p q; unsigned long a, b; m_link_p h = mp->h; #ifdef DEBUG printf("___sym_mfree(%p, %d)\n", ptr, size); #endif if (size > SYM_MEM_CLUSTER_SIZE) return; while (size > s) { s <<= 1; ++i; } a = (unsigned long)ptr; while (1) { if (s == SYM_MEM_CLUSTER_SIZE) { #ifdef SYM_MEM_FREE_UNUSED M_FREE_MEM_CLUSTER((void *)a); #else ((m_link_p) a)->next = h[i].next; h[i].next = (m_link_p) a; #endif break; } b = a ^ s; q = &h[i]; while (q->next && q->next != (m_link_p) b) { q = q->next; } if (!q->next) { ((m_link_p) a)->next = h[i].next; h[i].next = (m_link_p) a; break; } q->next = q->next->next; a = a & b; s <<= 1; ++i; } } /* * Verbose and zeroing allocator that wrapps to the generic allocator. */ static void *__sym_calloc2(m_pool_p mp, int size, char *name, int uflags) { void *p; p = ___sym_malloc(mp, size); if (DEBUG_FLAGS & DEBUG_ALLOC) { printf ("new %-10s[%4d] @%p.\n", name, size, p); } if (p) memset(p, 0, size); else if (uflags & SYM_MEM_WARN) printf ("__sym_calloc2: failed to allocate %s[%d]\n", name, size); return p; } #define __sym_calloc(mp, s, n) __sym_calloc2(mp, s, n, SYM_MEM_WARN) /* * Its counter-part. */ static void __sym_mfree(m_pool_p mp, void *ptr, int size, char *name) { if (DEBUG_FLAGS & DEBUG_ALLOC) printf ("freeing %-10s[%4d] @%p.\n", name, size, ptr); ___sym_mfree(mp, ptr, size); } /* * Default memory pool we donnot need to involve in DMA. * * With DMA abstraction, we use functions (methods), to * distinguish between non DMAable memory and DMAable memory. */ static void *___mp0_get_mem_cluster(m_pool_p mp) { void *m = sym_get_mem_cluster(); if (m) ++mp->nump; return m; } #ifdef SYM_MEM_FREE_UNUSED static void ___mp0_free_mem_cluster(m_pool_p mp, void *m) { sym_free_mem_cluster(m); --mp->nump; } #else #define ___mp0_free_mem_cluster NULL #endif static struct sym_m_pool mp0 = { NULL, ___mp0_get_mem_cluster, ___mp0_free_mem_cluster }; /* * Methods that maintains DMAable pools according to user allocations. * New pools are created on the fly when a new pool id is provided. * They are deleted on the fly when they get emptied. */ /* Get a memory cluster that matches the DMA constraints of a given pool */ static void * ___get_dma_mem_cluster(m_pool_p mp) { m_vtob_p vbp; void *vaddr; vbp = __sym_calloc(&mp0, sizeof(*vbp), "VTOB"); if (!vbp) goto out_err; vaddr = sym_m_get_dma_mem_cluster(mp, vbp); if (vaddr) { int hc = VTOB_HASH_CODE(vaddr); vbp->next = mp->vtob[hc]; mp->vtob[hc] = vbp; ++mp->nump; } return vaddr; out_err: return NULL; } #ifdef SYM_MEM_FREE_UNUSED /* Free a memory cluster and associated resources for DMA */ static void ___free_dma_mem_cluster(m_pool_p mp, void *m) { m_vtob_p *vbpp, vbp; int hc = VTOB_HASH_CODE(m); vbpp = &mp->vtob[hc]; while (*vbpp && (*vbpp)->vaddr != m) vbpp = &(*vbpp)->next; if (*vbpp) { vbp = *vbpp; *vbpp = (*vbpp)->next; sym_m_free_dma_mem_cluster(mp, vbp); __sym_mfree(&mp0, vbp, sizeof(*vbp), "VTOB"); --mp->nump; } } #endif /* Fetch the memory pool for a given pool id (i.e. DMA constraints) */ static inline m_pool_p ___get_dma_pool(m_pool_ident_t dev_dmat) { m_pool_p mp; for (mp = mp0.next; mp && !sym_m_pool_match(mp->dev_dmat, dev_dmat); mp = mp->next); return mp; } /* Create a new memory DMAable pool (when fetch failed) */ static m_pool_p ___cre_dma_pool(m_pool_ident_t dev_dmat) { m_pool_p mp = __sym_calloc(&mp0, sizeof(*mp), "MPOOL"); if (mp) { mp->dev_dmat = dev_dmat; mp->get_mem_cluster = ___get_dma_mem_cluster; #ifdef SYM_MEM_FREE_UNUSED mp->free_mem_cluster = ___free_dma_mem_cluster; #endif mp->next = mp0.next; mp0.next = mp; return mp; } return NULL; } #ifdef SYM_MEM_FREE_UNUSED /* Destroy a DMAable memory pool (when got emptied) */ static void ___del_dma_pool(m_pool_p p) { m_pool_p *pp = &mp0.next; while (*pp && *pp != p) pp = &(*pp)->next; if (*pp) { *pp = (*pp)->next; __sym_mfree(&mp0, p, sizeof(*p), "MPOOL"); } } #endif /* This lock protects only the memory allocation/free. */ static DEFINE_SPINLOCK(sym53c8xx_lock); /* * Actual allocator for DMAable memory. */ void *__sym_calloc_dma(m_pool_ident_t dev_dmat, int size, char *name) { unsigned long flags; m_pool_p mp; void *m = NULL; spin_lock_irqsave(&sym53c8xx_lock, flags); mp = ___get_dma_pool(dev_dmat); if (!mp) mp = ___cre_dma_pool(dev_dmat); if (!mp) goto out; m = __sym_calloc(mp, size, name); #ifdef SYM_MEM_FREE_UNUSED if (!mp->nump) ___del_dma_pool(mp); #endif out: spin_unlock_irqrestore(&sym53c8xx_lock, flags); return m; } void __sym_mfree_dma(m_pool_ident_t dev_dmat, void *m, int size, char *name) { unsigned long flags; m_pool_p mp; spin_lock_irqsave(&sym53c8xx_lock, flags); mp = ___get_dma_pool(dev_dmat); if (!mp) goto out; __sym_mfree(mp, m, size, name); #ifdef SYM_MEM_FREE_UNUSED if (!mp->nump) ___del_dma_pool(mp); #endif out: spin_unlock_irqrestore(&sym53c8xx_lock, flags); } /* * Actual virtual to bus physical address translator * for 32 bit addressable DMAable memory. */ dma_addr_t __vtobus(m_pool_ident_t dev_dmat, void *m) { unsigned long flags; m_pool_p mp; int hc = VTOB_HASH_CODE(m); m_vtob_p vp = NULL; void *a = (void *)((unsigned long)m & ~SYM_MEM_CLUSTER_MASK); dma_addr_t b; spin_lock_irqsave(&sym53c8xx_lock, flags); mp = ___get_dma_pool(dev_dmat); if (mp) { vp = mp->vtob[hc]; while (vp && vp->vaddr != a) vp = vp->next; } if (!vp) panic("sym: VTOBUS FAILED!\n"); b = vp->baddr + (m - a); spin_unlock_irqrestore(&sym53c8xx_lock, flags); return b; }