SIM card related Projects » SIMtrace

/* AT91SAM7 USB Request Context for OpenPCD / OpenPICC

 * (C) 2006 by Harald Welte <hwelte@hmw-consulting.de>

 *

 *  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; either version 2 of the License, or

 *  (at your option) any later version.

 *

 *  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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 */

#include <stdlib.h>

#include <asm/bitops.h>

#include <os/req_ctx.h>

/* FIXME: locking, FIFO order processing */

#define NUM_RCTX_LARGE 8

#define NUM_RCTX_LARGE 20

static uint8_t rctx_data_large[NUM_RCTX_LARGE][RCTX_SIZE_LARGE];

static struct req_ctx *req_ctx_queues[RCTX_STATE_COUNT], *req_ctx_tails[RCTX_STATE_COUNT];

				 unsigned long new_state)

		DEBUGPCR("Invalid parameters for req_ctx_find_get");

		return NULL;

	toReturn = req_ctx_queues[old_state];

	if (toReturn) {

		if ((req_ctx_queues[old_state] = toReturn->next))

			toReturn->next->prev = NULL;

		else

			req_ctx_tails[old_state] = NULL;

			toReturn->prev->next = toReturn;

		else

			req_ctx_queues[new_state] = toReturn;

		req_ctx_tails[new_state] = toReturn;

		toReturn->state = new_state;

		toReturn->next = NULL;

	local_irq_restore(flags);

	return toReturn;

		DEBUGPCR("Invalid new_state for req_ctx_set_state");

		return;

	}

	if (ctx->prev)

		ctx->prev->next = ctx->next;

	else

		req_ctx_queues[old_state] = ctx->next;

	if (ctx->next)

		ctx->next->prev = ctx->prev;

	else

		req_ctx_tails[old_state] = ctx->prev;

		ctx->prev->next = ctx;

	else

		req_ctx_queues[new_state] = ctx;

	req_ctx_tails[new_state] = ctx;

}

void req_print(int state) {

	int count = 0;

	struct req_ctx *ctx, *last = NULL;

	DEBUGP("State [%02i] start <==> ", state);

	ctx = req_ctx_queues[state];

	while (ctx) {

		if (last != ctx->prev)

			DEBUGP("*INV_PREV* ");

		DEBUGP("%08X => ", ctx);

		last = ctx;

		ctx = ctx->next;

		count++;

		if (count > NUM_REQ_CTX) {

		  DEBUGP("*WILD POINTER* => ");

		  break;

		}

	}

	DEBUGPCR("NULL");

	if (!req_ctx_queues[state] && req_ctx_tails[state]) {

		DEBUGPCR("NULL head, NON-NULL tail");

	}

	if (last != req_ctx_tails[state]) {

		DEBUGPCR("Tail does not match last element");

	}

}

#endif

{

	unsigned old_state;

	local_irq_save(intcFlags);

	old_state = ctx->state;

	if (ctx->prev)

		ctx->prev->next = ctx->next;

	else

		req_ctx_queues[old_state] = ctx->next;

	if (ctx->next)

		ctx->next->prev = ctx->prev;

	else

		req_ctx_tails[old_state] = ctx->prev;

		ctx->prev->next = ctx;

	else

		req_ctx_queues[RCTX_STATE_FREE] = ctx;

	req_ctx_tails[RCTX_STATE_FREE] = ctx;

	ctx->state = RCTX_STATE_FREE;

	ctx->next = NULL;

{

	if (state >= RCTX_STATE_COUNT)

		return 0;

	return req_counts[state];

}

{

	int i;

	for (i = 0; i < NUM_RCTX_SMALL; i++) {

		req_ctx[i].next = req_ctx + i + 1;

			i, req_ctx + i, req_ctx[i].data, req_ctx[i].data + RCTX_SIZE_SMALL);

		req_ctx[i].prev = req_ctx + i - 1;

		req_ctx[i].next = req_ctx + i + 1;

		req_ctx[i].size = RCTX_SIZE_LARGE;

		req_ctx[i].tot_len = 0;

		req_ctx[i].data = rctx_data_large[i];

		req_ctx[i].state = RCTX_STATE_FREE;

		DEBUGPCR("LARGE req_ctx[%02i] initialized at %08X, Data: %08X => %08X",

			i, req_ctx + i, req_ctx[i].data, req_ctx[i].data + RCTX_SIZE_LARGE);

	}

	req_ctx[0].prev = NULL;

	req_ctx[NUM_REQ_CTX - 1].next = NULL;

	req_ctx_queues[RCTX_STATE_FREE] = req_ctx;

	req_ctx_tails[RCTX_STATE_FREE] = req_ctx + NUM_REQ_CTX - 1;

	for (i = RCTX_STATE_FREE + 1; i < RCTX_STATE_COUNT; i++) {

		req_ctx_queues[i] = req_ctx_tails[i] = NULL;

}