/*
   * 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>
   *
   *-----------------------------------------------------------------------------
   *
   * This program is free software; you can redistribute it and/or modify
   * it under the terms of the GNU General Public License as published by
   * the Free Software Foundation; either version 2 of the License, or
   * (at your option) any later version.
   *
   * This program is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   * GNU General Public License for more details.
   *
   * You should have received a copy of the GNU General Public License
   * along with this program; if not, write to the Free Software
   * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   */

  #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
  ", 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)
  ", 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.
  ", name, size, p);
  	}
  
  	if (p)
  		memset(p, 0, size);
  	else if (uflags & SYM_MEM_WARN)
  		printf ("__sym_calloc2: failed to allocate %s[%d]
  ", 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.
  ", 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!
  ");
  	b = vp->baddr + (m - a);
  	spin_unlock_irqrestore(&sym53c8xx_lock, flags);
  	return b;
  }