forked from luck/tmp_suning_uos_patched
1a59d1b8e0
Based on 1 normalized pattern(s): 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 extracted by the scancode license scanner the SPDX license identifier GPL-2.0-or-later has been chosen to replace the boilerplate/reference in 1334 file(s). Signed-off-by: Thomas Gleixner <tglx@linutronix.de> Reviewed-by: Allison Randal <allison@lohutok.net> Reviewed-by: Richard Fontana <rfontana@redhat.com> Cc: linux-spdx@vger.kernel.org Link: https://lkml.kernel.org/r/20190527070033.113240726@linutronix.de Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
366 lines
8.0 KiB
C
366 lines
8.0 KiB
C
// 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;
|
|
}
|