linux/drivers/scsi/sym53c8xx_2/sym_malloc.c
<<
>>
Prefs
   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 developed 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