amt630hv160-sdk-release/amt630hv160-freertos-beta/ArkmicroFiles/libboard-amt630hv160/source/fb_queue.c

#include <stdio.h>

#include "rtos.h"
#include "xm_base.h"
#include "board.h"
#include "fb_queue.h"


#define MAX_FB_COUONT			4


typedef struct  fb_queue_info {
	queue_s ready_list;	// 已准备好的LCD帧链表
	queue_s free_list;	// 空闲链表
	void *fb_buf;
	int fb_count;
	fb_queue_s  frames[MAX_FB_COUONT];
} fb_queue_t;

static fb_queue_t *g_fq = NULL;


void queue_initialize(queue_s *queue)
{
	queue->prev = queue;
	queue->next = queue;
}

void queue_insert(queue_s *entry, queue_s *queue)
{
	entry->prev = queue->prev;
	entry->next = queue;
	queue->prev->next = entry;
	queue->prev = entry;
}

void queue_delete(queue_s *entry)
{
	if (entry->prev == entry || entry->next == entry)
	{
		//assert(0);
		printf("%s, assert\n", __func__);
	}
	if (entry->next != entry)
	{
		entry->prev->next = entry->next;
		entry->next->prev = entry->prev;

		entry->prev = entry;
		entry->next = entry;
	}
}

queue_s * queue_head(queue_s *queue)
{
	if (queue->next == queue)
	{
		//assert(0);
		printf("%s, assert\n", __func__);
	}
	return (queue_s *)queue->next;
}

queue_s * queue_tail(queue_s *queue)
{
	if (queue->next == queue)
	{
		//assert(0);
		printf("%s, assert\n", __func__);
	}
	return (queue_s *)queue->prev;
}

queue_s * queue_delete_next(queue_s *queue)
{
	volatile queue_s	*entry;
	if (queue->next == queue || queue->prev == queue)
	{
		//assert(0);
		printf("%s, assert\n", __func__);
	}
	entry = queue->next;
	queue->next = entry->next;
	entry->next->prev = queue;

	entry->prev = (queue_s *)entry;
	entry->next = (queue_s *)entry;

	return((queue_s *)entry);
}

queue_s * queue_next(queue_s *queue)
{
	return (queue_s *)queue->next;
}

queue_s * queue_prev(queue_s *queue)
{
	return (queue_s *)queue->prev;
}


int queue_empty(queue_s *queue)
{
	if (queue->next == queue)
	{
		if (queue->prev != queue)
		{
			//assert(0);
			printf("%s, assert\n", __func__);
		}
		return(1);
	}
	return(0);
}


fb_queue_s *fb_queue_get_free_unit(void)
{
	fb_queue_s *unit = NULL;

	if (g_fq)
	{
		XM_lock();
		if(!queue_empty (&g_fq->free_list))
		{
			unit = (fb_queue_s *)queue_delete_next (&g_fq->free_list);
		}
		XM_unlock();
	}

	return unit;
}

void fb_queue_set_free (fb_queue_s *unit)
{
	if (g_fq)
	{
		XM_lock();
		queue_insert ((queue_s *)unit, &g_fq->free_list);
		XM_unlock();
	}
}

void fb_queue_set_free_isr (fb_queue_s *unit)
{
	if (g_fq)
		queue_insert ((queue_s *)unit, &g_fq->free_list);
}

void fb_queue_set_ready (fb_queue_s *unit)
{
	if (g_fq)
	{
		XM_lock();
		queue_insert ((queue_s *)unit, &g_fq->ready_list);
		XM_unlock();
	}
}

fb_queue_s *fb_queue_get_ready_unit_isr(void)
{
	fb_queue_s *unit = NULL;

	if (g_fq)
	{
		if(!queue_empty (&g_fq->ready_list))
		{
			unit = (fb_queue_s *)queue_delete_next (&g_fq->ready_list);
		}
	}

	return unit;
}

fb_queue_s *fb_queue_get_ready_unit(void)
{
	fb_queue_s *unit = NULL;

	if (g_fq)
	{
		XM_lock();
		if(!queue_empty (&g_fq->ready_list))
		{
			unit = (fb_queue_s *)queue_delete_next (&g_fq->ready_list);
		}
		XM_unlock();
	}

	return unit;
}

fb_queue_s *fb_queue_get_unit_from_base(unsigned int base)
{
	if (g_fq)
	{
		for (int i = 0; i < g_fq->fb_count; i ++)
		{
			if(g_fq->frames[i].fb_base == base)
				return g_fq->frames + i;
		}
	}

	return NULL;
}

void *fb_queue_init(uint32_t fb_count, uint32_t fb_size)
{
	fb_queue_t *fq;

	if (!fb_count || !fb_size) {
		printf("ERR: %s, Invalid fb count:%d or size:%d.\n", __func__, fb_count, fb_size);
		return NULL;
	}

	if (fb_count > MAX_FB_COUONT) {
		printf("Warnning: %s, Invalid fb count:%d.\n", __func__, fb_count);
	}

	fq = pvPortMalloc(sizeof(fb_queue_t));
	if (!fq)
	{
		printf("ERR: %s, malloc fq fail.\n", __func__);
		return NULL;
	}

	queue_initialize (&fq->ready_list);
	queue_initialize (&fq->free_list);
	memset (fq->frames, 0, sizeof(fq->frames)); 

	fq->fb_count = fb_count;
	fq->fb_buf = pvPortMalloc(fb_size * fb_count);
	if (!fq->fb_buf)
	{
		printf("ERR: %s, malloc framebuffer fail.\n", __func__);
		return NULL;
	}
	memset(fq->fb_buf, 0, fb_size * fb_count);

	for (int i = 0; i < fb_count; i ++)
	{
		fq->frames[i].fb_base = i * fb_size + (unsigned int)fq->fb_buf;
		queue_insert ((queue_s *)(fq->frames + i), &fq->free_list);
	}

	g_fq = fq;

	return fq->fb_buf;
exit:
	if (fq) {
		if (fq->fb_buf)
			vPortFree(fq->fb_buf);
		vPortFree(fq);
	}
	g_fq = NULL;

	return NULL;
}

void fb_queue_exit (void)
{
	fb_queue_t *fq = g_fq;

	if (fq) {
		if (fq->fb_buf)
			vPortFree(fq->fb_buf);
		vPortFree(fq);
	}
	g_fq = NULL;
}