sram pool

最新推荐文章于 2024-07-07 13:14:51 发布

guolihua

最新推荐文章于 2024-07-07 13:14:51 发布

阅读量447

点赞数

分类专栏： C的学习文章标签： buffer table struct null header x86

C的学习专栏收录该内容

3 篇文章 0 订阅

订阅专栏

//public.h

#ifndef _PUBLIC_H_
#define _PUBLIC_H_

#define DEBUG
#define LOG
#define X86

#ifndef X86
#define Print printk
#else
#define Print printf
#endif

#ifndef DEBUG
#define DebugPrint(fmt,args...)
#else
#define DebugPrint(fmt,args...) Print("/n %s" fmt "","---DEBUG INFO---",##args)
#endif

#ifndef LOG
#define LogPrint(fmt,args...)
#else
#define LogPrint(fmt,args...) Print("/n %s" fmt "","---LOG INFO---",##args)
#endif
#ifdef X86
#define Kmalloc(a,b) malloc(a)
#else
#define Kmalloc(a,b) kmalloc(a,b)
#endif

/*define var*/
#define ture     1
#define false  0
#define null  0
#define null  0

/*typedef var*/
typedef unsigned char   UINT8;
typedef unsigned short UINT16;
typedef unsigned int     UINT32;
typedef unsigned long   UINT64;

typedef signed char INT8;
typedef signed short INT16;
typedef signed int INT32;
typedef signed long INT64;

typedef unsigned char BOOL;
typedef unsigned char byte;

/* public struct*/
typedef struct _BMHDTV_DEVICE_
{
    //struct pci_dev device;
    unsigned long       SramSpacePhyBase;
    unsigned long       SramSpaceVirtBase;
    unsigned long       SramSpaceSize;
    unsigned long       RegPhyBase;
    unsigned long       RagVirtBase;
    unsigned long       RegSize;
    int                     DeviceIrq;
} BMHDTV_DEVICE;

BMHDTV_DEVICE gBMHDTVdevice;

#endif

//SramPool.h

#ifndef _SRAM_POOL_H_
#define _SRAM_POOL_H_
#include "public.h"

#define MPEG2_BUFFER_BASE 54*1024*1024 //54M
#define MPEG2_BUFFER_SIZE 2*1024*1024 // 2m

#define DATA_BUFFER_BASE 58*1024*1024 //58M
#define DATA_BUFFER_SIZE 4*1024*1024 // 4M

#define SRAM_BUFFER_HEADER 5

/**************************************************************
A Node struct...return DATA addr;

***************************************************************/

typedef struct _DATA_BUFFER_{
UINT32 bpStartPos;
UINT32 blen;

}DATA_BUFFER,*PDATA_BUFFER;

typedef struct _NODE_TABLE_{

unsigned long StarAddr;
BOOL isUsed;

}NODE_TABLE,*PNODE_TABLE;

typedef struct _SPACE_TABLE_
{
UINT32   NodeSizeByte;
UINT32   MaxNodeNumber;
UINT32   NodeUsedNumber;

NODE_TABLE *pNodeTable;

}SPACE_TABLE,*PSPACE_TABLE;

typedef struct _POOL_TABLE_{
UINT32 TableNum;
SPACE_TABLE *pSpaceTable;

}POOLTABLE,*PPOOL_TABLE;

typedef struct _CONFIG_INFO_{
UINT8  NumberOfSpace;
UINT16  *pNodeSizeArry;
UINT16  *pNodeNumberArry;

}CONFIG_INFO,*PCONFIG_INFO;

POOLTABLE *gpPoolTable;

BOOL InitDevice();

BOOL ConfigSramPool(CONFIG_INFO mConfigInfomation);

BOOL InitSramPool(void);

void *RequstBuffer(int mlen);

BOOL FreeBuffer(void *mPoint);

void ShowThePoolStruct();

#define GetSramBuffer(len,type) (type *)RequstBuffer(len)
#define FreeSramBuffer(point) FreeBuffer((void *)point)

#endif

//SramPool.c

#include <string.h>
#include <stdio.h>
#include <stdlib.h>

#include "SramPool.h"

BOOL InitDevice()
{

#ifdef DEBUG
unsigned char * StartAddr = NULL;
int i, p = 0;
#endif

unsigned long nSramSize = DATA_BUFFER_SIZE;

LogPrint("Init Device....");

gBMHDTVdevice.RagVirtBase=-1;
gBMHDTVdevice.RegPhyBase=-1;
gBMHDTVdevice.RegSize=-1;
gBMHDTVdevice.SramSpaceVirtBase=-1;
gBMHDTVdevice.DeviceIrq=-1;
gBMHDTVdevice.SramSpaceVirtBase=-1;
gBMHDTVdevice.SramSpacePhyBase=DATA_BUFFER_BASE;
gBMHDTVdevice.SramSpaceSize = DATA_BUFFER_SIZE;

#ifndef X86
gBMHDTVdevice.SramSpaceVirtBase=(unsigned long) ioremap_nocache(gBMHDTVdevice.SramSpacePhyBase, nSramSize);
#else
gBMHDTVdevice.SramSpaceVirtBase=(unsigned long) malloc(4*1024*1024);
memset((UINT8 *)gBMHDTVdevice.SramSpaceVirtBase,0,4*1024*1024);
#endif

if(gBMHDTVdevice.SramSpaceVirtBase == (-1))
  {
   LogPrint("Device Init Failt.../n");
   return false;
  }

#ifndef DEBUG

DebugPrint("Testing.......");

StartAddr= (unsigned char *) gBMHDTVdevice.SramSpaceVirtBase;
     for (i = 0; i < nSramSize; i += 4)
     {
         *(StartAddr + i) = 'a';
         *(StartAddr + i + 1) = 'b';
         *(StartAddr + i + 2) = 'c';
         *(StartAddr + i + 3) = 'd';
     }
    for (p = 10   ; p > 0   ; p--)
    {
    #ifndef X86
        printk("%c ", *(StartAddr + nSramSize - p));
#else
         printf("%c ", *(StartAddr + nSramSize - p));
#endif
    }

#endif

LogPrint("Device Init OK.../n");

return ture;

}

BOOL ConfigSramPool(CONFIG_INFO mConfigInfomation)
{
UINT32  nSpaceNumber=0;
SPACE_TABLE *npSpaceTable=null;
NODE_TABLE *npNodeTable=null;
int    nSpaceCount,i;
UINT32  nNodeNumber;
UINT32  nTotalLens=0;;

LogPrint("--->Config The Sram Pool...");

gpPoolTable=(POOLTABLE *) Kmalloc(sizeof(POOLTABLE), GFP_KERNEL);
if(gpPoolTable==null)
  {
   LogPrint("Pool Table Init Fault...");
   return false;
  }

gpPoolTable->TableNum=mConfigInfomation.NumberOfSpace;
nSpaceNumber=mConfigInfomation.NumberOfSpace;
gpPoolTable->pSpaceTable=(SPACE_TABLE *)Kmalloc(sizeof(SPACE_TABLE)*nSpaceNumber,GPF_KERNEL);
npSpaceTable=gpPoolTable->pSpaceTable;

if(npSpaceTable==null)
  {
   LogPrint("Space Table Init Fault...");
   return false;
  }

for(i=0;i<nSpaceNumber;i++)
  {
   npSpaceTable[i].NodeSizeByte=mConfigInfomation.pNodeSizeArry[i]+SRAM_BUFFER_HEADER;
   npSpaceTable[i].MaxNodeNumber=mConfigInfomation.pNodeNumberArry[i];
   npSpaceTable[i].NodeUsedNumber=0;
   nNodeNumber=mConfigInfomation.pNodeNumberArry[i];
   npSpaceTable[i].pNodeTable=(NODE_TABLE *)Kmalloc(sizeof(NODE_TABLE)*nNodeNumber,GPF_KERNEL);
   npNodeTable=npSpaceTable[i].pNodeTable;

   if(npNodeTable==null)
    {
     LogPrint("Node Table %d Init Fault...",i);
     return false;
    }
   nTotalLens=nTotalLens+npSpaceTable[i].NodeSizeByte*npSpaceTable[i].MaxNodeNumber;

  }

if(nTotalLens>=DATA_BUFFER_SIZE)
  {
   Print("/n/ntotal lens:%ld/n/n",nTotalLens);
   LogPrint("Not ength monenry to save the buffer.../n/n");
   return false;
  }

LogPrint("<----Config The Sram Pool End...");
return ture;

}

BOOL InitSramPool(void)
{
int i,j,k;
UINT8 nTableNum;
SPACE_TABLE *npSpaceTable=null;
NODE_TABLE *npNodeTable=null;
UINT32 nNodeNumber;
UINT32 nNodeSize;

UINT8  *npMem;
UINT8   *npPoolBase;
UINT16  ntmp;

LogPrint("---->Init Sram Pool....");

npPoolBase=(UINT8 *)gBMHDTVdevice.SramSpaceVirtBase;
npMem=npPoolBase;

nTableNum=gpPoolTable->TableNum;
npSpaceTable=gpPoolTable->pSpaceTable;

if(npMem==null)
  {
   LogPrint("Base Ram is null....");
   return false;
  }

/*************************************************************
--------------------------------------------------------------
|SpaceTable   | NodeTable | buffer size          |   DATA (size)                |
| index          |    index      |           (len)         |                                    |
---------------------------------------------------------------
0                    8                 16                          32
**************************************************************/
for(i=0;i<nTableNum;i++)
  {
  // LogPrint("Init Space Table....");
   npNodeTable=npSpaceTable[i].pNodeTable;
   nNodeNumber=npSpaceTable[i].MaxNodeNumber;
   nNodeSize=npSpaceTable[i].NodeSizeByte;
   npSpaceTable[i].NodeUsedNumber=0;

// LogPrint("npSpaceTable[%d]:MaxNodeNumber %d,NodeSizeByte %d",i,nNodeNumber,nNodeSize);

   for(j=0;j<nNodeNumber;j++)
    {
     npNodeTable[j].isUsed=false;
     *npMem=i;
     *(npMem+1)=j>>8;
     *(npMem+2)=j&0xff;
     *(npMem+3)=nNodeSize>>8;
     *(npMem+4)=nNodeSize&0xff;
     ntmp=*(npMem+3);
     ntmp=(ntmp<<8)|(*(npMem+4));
     npNodeTable[j].StarAddr=(unsigned long)(npMem+5);
     npMem+=nNodeSize;
    }

}

LogPrint("<----Init Sram Pool....");

return ture;

}

void *RequstBuffer(int mlen)
{
int i=0;
int j=0;
UINT8 nTableNum;
SPACE_TABLE *npSpaceTable=null;
NODE_TABLE *npNodeTable=null;
UINT32 nNodeNumber;
UINT32 nNodeSize;

void   *npReqMem=null;
UINT8   *npPoolBase;
UINT16  ntmp;

nTableNum=gpPoolTable->TableNum;
npSpaceTable=gpPoolTable->pSpaceTable;

while(i<nTableNum)
  {
   if((npSpaceTable[i].NodeSizeByte>=mlen+SRAM_BUFFER_HEADER)&&
    (npSpaceTable[i].MaxNodeNumber>npSpaceTable[i].NodeUsedNumber))
    {
     npNodeTable=npSpaceTable[i].pNodeTable;
     nNodeNumber=npSpaceTable[i].MaxNodeNumber;
     nNodeSize=npSpaceTable[i].NodeSizeByte;

     while(npNodeTable[j].isUsed==ture)
       j++;
     npReqMem=(void *)npNodeTable[j].StarAddr;
     npNodeTable[j].isUsed=ture;
     npSpaceTable[i].NodeUsedNumber++;
     break;
    }
   i++;
  }

if(npReqMem == 0)
Print("The Requst Buffer addr is null/n/n");

return npReqMem;

}

BOOL FreeBuffer(void *mPoint)
{
UINT8 *nPointer;
UINT8 nSpaceIndex;
UINT16 nNodeIndex;

if(mPoint==null)
return false;

nPointer = (UINT8 *)mPoint;
nSpaceIndex=*(nPointer-5);
nNodeIndex=(*(nPointer-4)<<8)|(*(nPointer-3));
if(gpPoolTable->pSpaceTable[nSpaceIndex].pNodeTable[nNodeIndex].isUsed==ture)
  {
   gpPoolTable->pSpaceTable[nSpaceIndex].pNodeTable[nNodeIndex].isUsed=false;
   gpPoolTable->pSpaceTable[nSpaceIndex].NodeUsedNumber--;

   return ture;
  }
else
  {
   return false;
  }

}

void ShowThePoolStruct()
{
int i,j,k;
UINT32 nSpaceNum;
UINT32 nMaxNodeNum;

UINT8 *npMem=null;

nSpaceNum=gpPoolTable->TableNum;

Print("/n/n=====================Pool State===========================/n/n");
Print("Space Num:/t");
for(i=0;i<nSpaceNum;i++)
  Print("%d/t",i);
Print("/n");
Print("Space Len:/t");
for(i=0;i<nSpaceNum;i++)
  Print("%d/t",gpPoolTable->pSpaceTable[i].NodeSizeByte);
Print("/n");
Print("Node Num:/t");
for(i=0;i<nSpaceNum;i++)
  Print("%d/t",gpPoolTable->pSpaceTable[i].MaxNodeNumber);
Print("/n");
Print("Node Used:/t");
for(i=0;i<nSpaceNum;i++)
  Print("%d/t",gpPoolTable->pSpaceTable[i].NodeUsedNumber);

Print("/n/n=====================Pool State END========================/n/n");

#if 0
for(i=0;i<nSpaceNum;i++)
  {
   LogPrint("index SpaceNum:%d",i);
   LogPrint("MaxNodeNumber:%d",gpPoolTable->pSpaceTable[i].MaxNodeNumber);
   LogPrint("NodeSizeByte:%d",gpPoolTable->pSpaceTable[i].NodeSizeByte);
   LogPrint("NodeUsedNumber:%d",gpPoolTable->pSpaceTable[i].NodeUsedNumber);
   nMaxNodeNum=gpPoolTable->pSpaceTable[i].MaxNodeNumber;
   for(j=0;j<nMaxNodeNum;j++)
    {
     LogPrint("index Node:%d",j);
     LogPrint("StarAddr:%x",gpPoolTable->pSpaceTable[i].pNodeTable[j].StarAddr);
     LogPrint("isUsed:%x",gpPoolTable->pSpaceTable[i].pNodeTable[j].isUsed);

     npMem=(UINT8 *)(gpPoolTable->pSpaceTable[i].pNodeTable[j].StarAddr-SRAM_BUFFER_HEADER);
     #ifdef DEBUG
     for(k=0;k<gpPoolTable->pSpaceTable[i].NodeSizeByte;k++)
      {
      if(k%16==0)
       Print("/n");
      Print("%x ",*(npMem+k));
      }
     #endif

    }

   LogPrint("+++++++++++++++++++++++++++++++++++++++++++++++++++++++");
  }

#endif

}

#ifdef X86

#define NumberOfBufferSizes 9
#define BufferSizesArry { 16, 48, 64, 288, 512, 1320, 1400, 1480, 1580}
#define NumberOfBuffersArry { 8, 4, 7, 4, 2, 6, 400, 300, 500}

static UINT16 gBufferSizes[NumberOfBufferSizes] = BufferSizesArry;
static UINT16 gBufferNumbers[NumberOfBufferSizes] = NumberOfBuffersArry;

typedef struct _TEST_NODE_
{
UINT8 testData;
UINT32 testUdata;
int testInt;
int testData2;
struct _TEST_NODE_ *pTestNodeNext;;
}TESTNODE,*PTESTNODE;

int main()
{
CONFIG_INFO nConfigInfomation={0};
UINT8 *nTest[13];
int i,j;
TESTNODE *pTest=null;
TESTNODE *pt=null,*header=null;

nConfigInfomation.NumberOfSpace=NumberOfBufferSizes;
nConfigInfomation.pNodeNumberArry=gBufferNumbers;
nConfigInfomation.pNodeSizeArry=gBufferSizes;

InitDevice();

if(!ConfigSramPool(nConfigInfomation))
return 0;

InitSramPool();

/*
for(i=0;i<13;i++)
nTest[i]=GetSramBuffer(1400, UINT8);

for(i=0;i<9;i++)
for(j=0;j<1400;j++)
nTest[i][j]=j;

ShowThePoolStruct();

for(i=0;i<13;i++)
FreeSramBuffer(nTest[i]);

ShowThePoolStruct();
*/

pTest=GetSramBuffer(sizeof(TESTNODE), TESTNODE);
pt=pTest->pTestNodeNext;
header=pTest;
for(i=0;i<1500;i++)
  {
   pt=GetSramBuffer(sizeof(TESTNODE), TESTNODE);
   if(pt!=null)
    {
     pt->testData=1;
     pt->testUdata=0x11223344;
     pt->testInt=0x55667788;
     pt->pTestNodeNext=null;
     pTest->pTestNodeNext=pt;
     pTest=pt;
    }
  }

ShowThePoolStruct();

   pt=header;
   while(pt->pTestNodeNext!=null)
    {
     pt=pt->pTestNodeNext;
     FreeSramBuffer(pt);
    }
ShowThePoolStruct();

return 0;
}

#endif