drivers/scsi/sym53c8xx_2/sym_malloc.c

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