cdcm/cdcmMem.c

   1 /**
   2  * @file cdcmMem.c
   3  *
   4  * @brief All @b CDCM memory handling is located here.
   5  *
   6  * @author Georgievskiy Yury, Alain Gagnaire. CERN AB/CO.
   7  *
   8  * @date Created on 17/02/2007
   9  *
  10  * Many thanks to Julian Lewis and Nicolas de Metz-Noblat.
  11  *
  12  * @version
  13  */
  14 #include "general_drvr.h"       /* various defs */
  15 #include "cdcmDrvr.h"
  16 #include "cdcmMem.h"
  17
  18 /* CDCM global variables (declared in the cdcmDrvr.c module)  */
  19 extern cdcmStatics_t cdcmStatT; /* CDCM statics table */
  20
  21 /**
  22  * @brief Release previously allocated memory
  23  *
  24  * @param pntr - mem pointer to release, returned by @e cdcm_mem_alloc.
  25  */
  26 void cdcm_mem_free(void *addr)
  27 {
  28         struct cdcm_mem_header *buf = addr;
  29         ssize_t realsize;
  30
  31         if (addr == NULL)
  32                 return;
  33         buf--;
  34         realsize = buf->size + sizeof(*buf);
  35
  36         if (realsize > MEM_BOUND)
  37                 vfree(buf);
  38         else
  39                 kfree(buf);
  40 }
  41
  42 /**
  43  * @brief Allocates memory.
  44  *
  45  * @param size - size in @b bytes
  46  * @param flags - memory flags (see @e cdcmm_t definition
  47  *               for more info on the possible flags)
  48  *
  49  * @return -ENOMEM                  - if fails.
  50  * @return allocated memory pointer - if success.
  51  */
  52 void *cdcm_mem_alloc(ssize_t size, int flags)
  53 {
  54         struct cdcm_mem_header *buf;
  55         size_t realsize = size + sizeof(*buf);
  56
  57         /*
  58          * For large buffers we use vmalloc, because kmalloc allocates
  59          * physically contiguous pages.
  60          */
  61         if (realsize > MEM_BOUND)
  62                 buf = vmalloc(realsize);
  63         else
  64                 buf = kmalloc(realsize, GFP_KERNEL);
  65
  66         if (buf == NULL) {
  67                 PRNT_ERR(cdcmStatT.cdcm_ipl, "Can't alloc 0x%x bytes", realsize);
  68                 return ERR_PTR(-ENOMEM);
  69         }
  70         buf->size = size;
  71         buf->flags = flags;
  72         return ++buf;
  73 }
  74
  75 /**
  76  * get_phys - get physical address of a virtual address !TODO!
  77  *
  78  * @param vaddr: virtual address
  79  *
  80  * returns the physical address onto which the given virtual address is mapped.
  81  * Some hardware devices may require a corresponding physical address
  82  * if they, for example, access physical memory directly (DMA) without the
  83  * benefit of the MMU. The value returned by get_phys minus PHYSBASE may be used
  84  * for such purposes.
  85  *
  86  * @return
  87  */
  88 char *get_phys(long vaddr)
  89 {
  90         return 0;
  91 }
  92
  93
  94 /**
  95  * mem_lock - guarantees address range is in real memory
  96  *
  97  * @param tjob: process ID that wants to lock memory
  98  * @param start:virtual start address, in bytes
  99  * @param size: size of the region of memory to lock, in bytes
 100  *
 101  * mem_lock guarantees that a region of virtual memory is locked into physical
 102  * memory. mem_lock returns OK if it can lock all the requested memory
 103  * otherwise it will return SYSERR.
 104  *
 105  * @return
 106  */
 107 int mem_lock(int tjob, char *start, unsigned long size)
 108 {
 109         return OK;
 110 }
 111
 112
 113 /**
 114  * mem_unlock - frees real memory for swapping !TODO!
 115  *
 116  * @param tjob: process ID that wants to lock memory
 117  * @param start: is the virtual start address, in bytes
 118  * @param size: is the size of the region of memory to lock, in bytes
 119  * @param dirty: if dirty is non 0 then the entire section of memory from
 120  * start to size will be marked as dirty. Dirty pages will be written to disk
 121  * by the VM mechanism in the kernel before they are released.
 122  *
 123  * mem_unlock unlocks the previously locked region of virtual memory which
 124  * allows the memory to be swapped. mem_unlock returns OK if the region
 125  * has been successfully unlocked otherwise it will return SYSERR
 126  *
 127  * @return
 128  */
 129
 130
 131 /**
 132  * get1page - get one page of physical memory
 133  *
 134  * allocates one page of physical memory and returns a virtual address
 135  * which can be used to access it.
 136  *
 137  * @return
 138  */
 139 char *get1page()
 140 {
 141         return (char *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
 142 }
 143
 144 /**
 145  * @brief free a page allocated with get1page()
 146  *
 147  * @param addr - address of the page
 148  */
 149 void free1page(void *addr)
 150 {
 151         return free_page((unsigned long)addr);
 152 }