gh_list_elem *gh_list_prepend(gh_list *list, void *data) {
gh_list_elem *newelem;
gh_list_elem *oldfirst;
SAFETY_CHECK_LIST(list);
newelem = get_free_buffer(list);
oldfirst = list->first;
if (oldfirst) {
oldfirst->prev = newelem;
newelem->next = oldfirst;
} else {
newelem->next = NULL;
}
newelem->prev = NULL;
newelem->data = data;
#ifndef NDEBUG
newelem->magic = GH_LIST_MAGIC;
#endif
list->count++;
list->first = newelem;
if (list->count == 1)
list->last = newelem;
return newelem;
}
gh_list_elem *gh_list_insert_before(gh_list *list, gh_list_elem *before, void *data) {
gh_list_elem *newelem;
SAFETY_CHECK_LIST(list);
SAFETY_CHECK_ELEM(before);
/* create or reuse a new cell */
newelem = get_free_buffer(list);
newelem->data = data;
newelem->prev = before->prev;
newelem->next = before;
#ifndef NDEBUG
newelem->magic = GH_LIST_MAGIC;
#endif
if (before->prev)
before->prev->next = newelem;
else
list->first = newelem;
before->prev = newelem;
list->count++;
return newelem;
}
void send_data_by_dma()
{
int ret;
unsigned int offset;
ACCESS_MGMT:
while ((ret = access_mgmt_area((u32 *)mapped_pci,
mgmt_area.my_unique_id)) < 0) {
debug_print("mgmt area access not granted\n");
sleep(3);
continue;
}
while ((ret = get_free_buffer((u32 *)mapped_pci)) < 0) {
debug_print("buffer not available\n");
release_mgmt_area((u32 *)mapped_pci);
sleep(3);
goto ACCESS_MGMT;
}
offset = offset_to_buffer((u32 *)mapped_pci, ret);
send_to_remote_buf_by_dma((u32 *)mapped_pci, 0x20000000,
offset, ret, fd_dma);
debug_print("send by dma successful\n");
release_mgmt_area((u32 *)mapped_pci);
}
static void clean_free_buffer(struct mtk_vcodec_ctx *ctx)
{
struct vb2_buffer *framptr;
do {
framptr = get_free_buffer(ctx);
} while (framptr);
}
void *
new_bufferlike_header(struct Parrot_Interp *interpreter, size_t size)
{
struct Small_Object_Pool *pool;
pool = get_bufferlike_pool(interpreter, size);
return get_free_buffer(interpreter, pool);
}
STRING *
new_string_header(struct Parrot_Interp *interpreter, UINTVAL flags)
{
STRING *string;
string = get_free_buffer(interpreter, (flags & PObj_constant_FLAG)
? interpreter->
arena_base->constant_string_header_pool :
interpreter->arena_base->string_header_pool);
PObj_flags_SETTO(string, flags | PObj_is_string_FLAG);
SET_NULL(string->strstart);
return string;
}
/* malloc function. Initializes the first page if needed, then
returns the appropriate allocated space. */
void* kma_malloc(kma_size_t size)
{
if (REALSIZE(size)+sizeof(pageheaderT) > PAGESIZE)
return NULL;
if (first_page == NULL)
{
first_page = init_page();
kma_malloc(sizeof(pageheaderT)); // mallocs the page header so it isn't overwritten.
PAGE_HEADER(first_page)->used = 0; // resets the allocation counter because the page
// header doesn't count.
}
return get_free_buffer(size);
}
struct buffer_head *getblk(kdev_t dev, block_t block)
{
register struct buffer_head *bh;
/* If there are too many dirty buffers, we wake up the update process
* now so as to ensure that there are still clean buffers available
* for user processes to use (and dirty) */
do {
bh = get_hash_table(dev, block);
if (bh != NULL) {
if (buffer_clean(bh) && buffer_uptodate(bh))
put_last_lru(bh);
return bh;
}
/* I think the following check is redundant
* So I will remove it for now
*/
} while(find_buffer(dev, block));
/*
* Create a buffer for this job.
*/
bh = get_free_buffer();
/* OK, FINALLY we know that this buffer is the only one of its kind,
* and that it's unused (b_count=0), unlocked (buffer_locked=0), and clean
*/
bh->b_count = 1;
bh->b_dirty = 0;
bh->b_lock = 0;
bh->b_uptodate = 0;
bh->b_dev = dev;
bh->b_blocknr = block;
bh->b_seg = kernel_ds;
return bh;
}
buffer_t* get_shared_buffer(int object_address){
node_t* temp_node;
buffer_t* new_buff;
/*TODO: fix this up, nobody calls this anymore so it is irrelevant*/
/*look for a pre-existing shared buffer*/
for (temp_node = buffer_list;temp_node;temp_node=temp_node->next){
if ((BUFF_SHARE == buffer_get_flags((buffer_t*)temp_node->data))&&\
(!buffer_check_reference((buffer_t*)temp_node->data,object_address))){
if ((buffer_add_reference((buffer_t*)temp_node->data,object_address,BUFF_SHARE))<0) return 0;
return (buffer_t*)temp_node->data;
}
}
/*couldn't find a shareable buffer so make one*/
if (!(new_buff = get_free_buffer())) return 0;
if ((buffer_add_reference(new_buff,object_address,BUFF_SHARE))<0) return 0;
return new_buff;
}
buffer_t* get_working_buffer(int index){
node_t* temp_node;
buffer_t* new_buff;
int i;
/*
Current imp: don't mark indexes of working buffer, just count on
them being in order. First working buffer in buffer_list is
working buffer 0, next one is 1, etc. Multiple working buffers
are needed for rtobjects with multiple output ports.
*/
/*look for a pre-existing working buffer with matching index*/
i=0;
for (temp_node = buffer_list;temp_node;temp_node=temp_node->next){
if ((BUFF_WORKING == buffer_get_flags((buffer_t*)temp_node->data))&&(index == i++))
return (buffer_t*)temp_node->data;
}
/*the requested working buffer doesn't exist yet, so make it*/
if (!(new_buff = get_free_buffer())) return 0;
if ((buffer_add_reference(new_buff,-1,BUFF_WORKING))<0) return 0;
return new_buff;
}
ssize_t ar6000_htc_raw_write(AR_SOFTC_T *ar, HTC_RAW_STREAM_ID StreamID,
char __user *buffer, size_t length)
{
int writePtr;
raw_htc_buffer *free;
AR_RAW_HTC_T *arRaw = ar->arRawHtc;
if (arRawStream2EndpointID(ar,StreamID) == 0) {
AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("StreamID(%d) not connected! \n", StreamID));
return -EFAULT;
}
if (down_interruptible(&arRaw->raw_htc_write_sem[StreamID])) {
return -ERESTARTSYS;
}
/* Search for a free buffer */
free = get_free_buffer(ar,StreamID);
/* Check if there is space to write else wait */
while (!arRaw->write_buffer_available[StreamID]) {
up(&arRaw->raw_htc_write_sem[StreamID]);
/* Wait for buffer to become free */
AR_DEBUG_PRINTF(ATH_DEBUG_HTC_RAW,("Sleeping StreamID(%d) write process\n", StreamID));
if (wait_event_interruptible(arRaw->raw_htc_write_queue[StreamID],
arRaw->write_buffer_available[StreamID]))
{
return -EINTR;
}
if (down_interruptible(&arRaw->raw_htc_write_sem[StreamID])) {
return -ERESTARTSYS;
}
free = get_free_buffer(ar,StreamID);
}
/* Send the data */
writePtr = HTC_HEADER_LEN;
if (length > (HTC_RAW_BUFFER_SIZE - HTC_HEADER_LEN)) {
length = HTC_RAW_BUFFER_SIZE - HTC_HEADER_LEN;
}
if (copy_from_user(&free->data[writePtr], buffer, length)) {
up(&arRaw->raw_htc_read_sem[StreamID]);
return -EFAULT;
}
free->length = length;
SET_HTC_PACKET_INFO_TX(&free->HTCPacket,
free,
&free->data[writePtr],
length,
arRawStream2EndpointID(ar,StreamID),
AR6K_DATA_PKT_TAG);
HTCSendPkt(ar->arHtcTarget,&free->HTCPacket);
arRaw->write_buffer_available[StreamID] = FALSE;
up(&arRaw->raw_htc_write_sem[StreamID]);
return length;
}
Buffer *
new_buffer_header(struct Parrot_Interp *interpreter)
{
return get_free_buffer(interpreter,
interpreter->arena_base->buffer_header_pool);
}
/* Searches all of the free buffers across all pages for one that
properly fits the requested size (adjusted for alloc header).
This searches all pages for given buffer size before moving on
to the bigger size, splitting the larger buffer down if necessary.
If none of the pages can fit the requested size, a new page is
allocated and a page header created and allocated. In the special
case of the buffer request being > PAGESIZE/2 a new page is always
allocated.
*/
void* get_free_buffer(int size)
{
pageheaderT* page_header = PAGE_HEADER(first_page);
pageheaderT* prev_page = NULL;
int i = 0;
int search_size = round_up(REALSIZE(size));
allocheaderT* to_be_allocated;
freelistL* buffer_size = get_required_buffer(search_size, page_header);
// Loops through each buffer size
while (search_size <= PAGESIZE)
{
// Loops through each page until it goes through all of them or
// finds a free buffer.
while (page_header != NULL && buffer_size->first_block == NULL)
{
prev_page = page_header;
page_header = page_header->next;
buffer_size = get_required_buffer(search_size, page_header);
}
// None found, increase size and repeat
if (buffer_size == NULL)
{
i++;
page_header = PAGE_HEADER(first_page);
prev_page = NULL;
search_size = search_size * 2;
buffer_size = get_required_buffer(search_size, page_header);
}
// Found. Splits depending on the number of times through the loop,
// removes the buffer from the free list, and returns it.
else
{
to_be_allocated = buffer_size->first_block;
if (i == 0)
{
buffer_size->first_block = to_be_allocated->next;
}
else
{
for(; i > 0; i--)
{
buffer_size = split_buffer(buffer_size, page_header);
}
to_be_allocated = buffer_size->first_block;
buffer_size->first_block = to_be_allocated->next;
}
page_header->used += 1;
return to_be_allocated;
}
}
// No buffers found. Find the last page again.
while (page_header != NULL)
{
prev_page = page_header;
page_header = page_header->next;
}
// Create a new page, split it up to insert the header.
kma_page_t* new_page = init_page();
page_header = PAGE_HEADER(new_page);
prev_page->next = page_header;
buffer_size = get_required_buffer(sizeof(pageheaderT), page_header);
to_be_allocated = buffer_size->first_block;
i = 0;
while (buffer_size != NULL && buffer_size->first_block == NULL)
{
buffer_size = buffer_size->bigger_size;
i++;
}
for(; i > 0; i--)
{
buffer_size = split_buffer(buffer_size, page_header);
}
to_be_allocated = buffer_size->first_block;
buffer_size->first_block = to_be_allocated->next;
// If size > PAGESIZE/2, clears free headers and allocates the
// whole page.
if (round_up(REALSIZE(size)) == PAGESIZE)
{
page_header->free_headers.buffer32.first_block = NULL;
page_header->free_headers.buffer64.first_block = NULL;
page_header->free_headers.buffer128.first_block = NULL;
page_header->free_headers.buffer256.first_block = NULL;
page_header->free_headers.buffer512.first_block = NULL;
page_header->free_headers.buffer1024.first_block = NULL;
page_header->free_headers.buffer2048.first_block = NULL;
page_header->free_headers.buffer4096.first_block = NULL;
page_header->free_headers.buffer8192.first_block = NULL;
page_header->used += 1;
return (void*)((long int) page_header + sizeof(pageheaderT));
}
// Now that the page has been created, try allocating again.
return get_free_buffer(size);
}
