[mirror_ubuntu-zesty-kernel.git] / drivers / scsi / sym53c8xx_2 / sym_malloc.c

/*
 * 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\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;
}
Commit	Line	Data
1da177e4 LT	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
1da177e4	40	#include "sym_glue.h"
1da177e4 LT	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	*
25985edc	53	* This allocator has been developed for the Linux sym53c8xx
1da177e4 LT	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	*/
	60	static 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	*/
	106	static 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	*/
158	static 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	*/
179	static 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	*/
193	static 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
202	static 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
211	static 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 */
223	static 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;
240	out_err:
241	return NULL;
242	}
243
244	#ifdef SYM_MEM_FREE_UNUSED
245	/* Free a memory cluster and associated resources for DMA */
246	static 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) */
1beb6fa8	265	static inline m_pool_p ___get_dma_pool(m_pool_ident_t dev_dmat)
1da177e4 LT	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) */
	275	static 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) */
	293	static 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. */
	307	static DEFINE_SPINLOCK(sym53c8xx_lock);
	308
	309	/*
	310	* Actual allocator for DMAable memory.
	311	*/
	312	void __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
335	void __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	*/
357	dma_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	}