linux-firmware 1.127 / lib / firmware / carl9170fw / tools / include / frame.h

/*
 * 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 version 2 of the License.
 *
 * 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.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Most ideas and some code are copied from the linux' kernels
 *	include/linux/skbuff.h
 */

#ifndef __TOOLS_FRAME_H
#define __TOOLS_FRAME_H

#include "SDL.h"
#include "list.h"

/**
 * struct frame_queue - sk_buff_head like frame queue
 *
 * @list: pointer to head and tail
 * @lock: mutex lock for serialize access
 * @len: exact number of queued frames
 */

struct frame_queue {
	struct list_head list;
	SDL_mutex *lock;
	size_t len;
};

/**
 * struct frame - frame data structure (like sk_buff)
 *
 * @list: storage for double-linked &struct frame_queue list
 * @dev: pointer to private device/driver structure
 * @timestamp: space for the current timestamp
 * @cb: private driver data
 * @dcb: more reserved space for low-level / backend driver
 * @queue: selected frame queue / priority
 * @ref: reference counter
 * @alloced: maximum available space
 * @total_len: currently consumed and reserved memory
 * @len: current frame length
 * @head: points to the buffer head
 * @data: current frame data pointer
 * @tail: frame data tail pointer
 * @payload: frame data storage container
 */

struct frame {
	struct list_head list;
	void *dev;
	unsigned long timestamp;
	uint8_t cb[64];
	union {
		struct list_head list;
		uint8_t raw_data[32];
	} dcb;

	unsigned int queue;
	unsigned int ref;
	unsigned int alloced;
	unsigned int total_len;
	unsigned int len;
	uint8_t *head;
	uint8_t *data;
	uint8_t *tail;

	/* payload must be the last entry */
	uint8_t payload[0];
};

/**
 * frame_put - append more data to &struct frame
 *
 * Allocate @size bytes from &struct frame tail and
 * returns a pointer to the requested location.
 *
 * @frame: frame to alter
 * @size: extra size
 */
static inline void *frame_put(struct frame *frame, unsigned int size)
{
	void *tmp;

	BUG_ON(frame->total_len + size > frame->alloced);

	frame->len += size;
	frame->total_len += size;

	tmp = (void *) frame->tail;
	frame->tail += size;

	BUG_ON(frame->tail > (frame->payload + frame->alloced));

	return tmp;
}

/**
 * frame_push - allocate head
 *
 * returns a pointer to a newly allocate area at &struct frame head.
 *
 * @frame: frame to modify
 * @size: requested extra size
 */
static inline void *frame_push(struct frame *frame, unsigned int size)
{
	frame->len += size;
	frame->data -= size;

	BUG_ON(frame->data < frame->payload);
	return frame->data;
}

/**
 * frame_get - reference frame buffer
 *
 * grab a reference from the frame buffer, in order to
 * prevent it from being freed prematurely by a different user.
 *
 * @frame: frame pointer
 */
static inline struct frame *frame_get(struct frame *frame)
{
	frame->ref++;
	return frame;
}

/**
 * frame_pull - remove space from &struct frame head
 *
 * Does the opposite of frame_push() and removes freed-up
 * space at the frames's head.
 *
 * @frame: pointer to frame structure
 * @size: bytes to remove from head
 */
static inline void *frame_pull(struct frame *frame, unsigned int size)
{
	BUG_ON(frame->len < size);

	frame->len -= size;
	frame->total_len -= size;
	frame->data += size;

	return frame->data;
}

/**
 * frame_reserve - reserve frame headroom
 *
 * Reserve a certain amount of space to allow headroom manipulations
 * in the future.
 *
 * @frame: frame to adjust
 * @size: bytes to reserve
 */
static inline void frame_reserve(struct frame *frame, unsigned int size)
{
	BUG_ON(frame->total_len + size > frame->alloced);
	BUG_ON(frame->len != 0);

	frame->total_len += size;
	frame->data += size;
	frame->tail += size;
}

/**
 * frame_trim - set frame length
 *
 * cut the frame to @size length.
 *
 * @frame: frame to be trimmed
 * @size: new length
 */
static inline void frame_trim(struct frame *frame, unsigned int size)
{
	BUG_ON(size > frame->total_len);

	frame->len = size;
	frame->total_len = size;
	frame->data = frame->head;
	frame->tail = frame->head + size;
}

/**
 * frame_alloc - alloc and initialize new frame
 *
 * returns a newly created &struct frame object.
 *
 * @size: maximum frame size of the new frame
 */
static inline struct frame *frame_alloc(unsigned int size)
{
	struct frame *tmp;

	tmp = malloc(size + sizeof(*tmp));
	if (tmp != NULL) {
		memset(tmp, 0, sizeof(*tmp));
		init_list_head(&tmp->list);
		init_list_head(&tmp->dcb.list);
		tmp->len = 0;
		tmp->total_len = 0;
		tmp->alloced = size;

		tmp->head = tmp->payload;
		tmp->data = tmp->payload;
		tmp->tail = tmp->payload;
		tmp->ref = 1;
	}
	return tmp;
}

/**
 * frame_free - unref and free frame
 *
 * Unreference frame and free it up, if all users are gone.
 *
 * @frame: frame to be freed
 */
static inline void frame_free(struct frame *frame)
{
	if (!--frame->ref)
		free(frame);
}

/**
 * FRAME_WALK - MACRO walker
 *
 * Walks over all queued elements in &struct frame_queue
 *
 * NOTE: This function is vulnerable in concurrent access
 *	 scenarios without proper locking.
 *
 * @pos: current position inside the queue
 * @head: &struct frame_queue head
 */
#define FRAME_WALK(pos, head)					\
	list_for_each_entry((pos), &(head)->list, list)

static inline void __frame_queue_init(struct frame_queue *queue)
{
	queue->len = 0;
	init_list_head(&queue->list);
}

/**
 * frame_queue_init - initialize frame_queue
 *
 * Initialize the given &struct frame_queue object.
 *
 * @queue: frame_queue to be initialized
 */
static inline void frame_queue_init(struct frame_queue *queue)
{
	queue->lock = SDL_CreateMutex();
	__frame_queue_init(queue);
}

/**
 * frame_queue_len - returns number of queue elements
 *
 * @queue: frame_queue object
 */
static inline unsigned int frame_queue_len(struct frame_queue *queue)
{
	return queue->len;
}

/**
 * frame_queue_empty - returns %TRUE whenever queue is empty
 *
 * @queue: frame_queue object
 */
static inline bool frame_queue_empty(struct frame_queue *queue)
{
	return list_empty(&queue->list);
}

static inline void __frame_queue_head(struct frame_queue *queue, struct frame *frame)
{
	list_add_head(&frame->list, &queue->list);
	queue->len++;
}

/**
 * frame_queue_head - queue a frame at the queues head
 * @queue: queue to use
 */
static inline void frame_queue_head(struct frame_queue *queue, struct frame *frame)
{
	BUG_ON((SDL_mutexP(queue->lock) != 0));
	__frame_queue_head(queue, frame);
	SDL_mutexV(queue->lock);
}

static inline void __frame_queue_tail(struct frame_queue *queue, struct frame *frame)
{
	list_add_tail(&frame->list, &queue->list);
	queue->len++;
}

/**
 * frame_queue_head - queue a frame at the queues tail
 * @queue: queue to use
 */
static inline void frame_queue_tail(struct frame_queue *queue, struct frame *frame)
{
	BUG_ON((SDL_mutexP(queue->lock) != 0));
	__frame_queue_tail(queue, frame);
	SDL_mutexV(queue->lock);
}

static inline void __frame_unlink(struct frame_queue *queue, struct frame *frame)
{
	list_del(&frame->list);
	queue->len--;
}

/**
 * frame_queue_unlink - remove a frame from the queue
 * @queue: queue to use
 * @frame: frame to remove
 */
static inline void frame_unlink(struct frame_queue *queue, struct frame *frame)
{
	BUG_ON((SDL_mutexP(queue->lock) != 0));
	__frame_unlink(queue, frame);
	SDL_mutexV(queue->lock);
}


static inline struct frame *__frame_dequeue(struct frame_queue *queue)
{
	struct frame *tmp = NULL;

	if (!frame_queue_empty(queue)) {
		tmp = list_entry(queue->list.next, struct frame, list);
		__frame_unlink(queue, tmp);
	}

	return tmp;
}

/**
 * frame_dequeue - remove frame from the head of the queue
 *
 * @queue: queue to dequeue from
 */
static inline struct frame *frame_dequeue(struct frame_queue *queue)
{
	struct frame *tmp;

	BUG_ON((SDL_mutexP(queue->lock) != 0));

	tmp = __frame_dequeue(queue);
	SDL_mutexV(queue->lock);
	return tmp;
}

static inline void __frame_queue_purge(struct frame_queue *queue)
{
	while (list_empty(&queue->list) == false)
		frame_free(__frame_dequeue(queue));
}

/**
 * frame_queue_purge - frees all queued &struct frame objects
 *
 * @queue: queue to be freed
 */
static inline void frame_queue_purge(struct frame_queue *queue)
{
	BUG_ON((SDL_mutexP(queue->lock) != 0));
	__frame_queue_purge(queue);
	SDL_mutexV(queue->lock);
}

/**
 * frame_queue_kill - destroys frame_queue object
 *
 * Destroy object and frees up all remaining elements
 *
 * @queue: frame_queue victim
 */
static inline void frame_queue_kill(struct frame_queue *queue)
{
	SDL_DestroyMutex(queue->lock);
	__frame_queue_purge(queue);
}

#endif /* __TOOLS_FRAME_H */