CRIS v32: Change lib/spinlock.S to use byte operations instead of dwords.

// $Id: vcs_hook.c,v 1.2 2003/08/12 12:01:06 starvik Exp $

//

// Call simulator hook. This is the part running in the

// simulated program.

//

#include "vcs_hook.h"

#include <stdarg.h>

#include <asm/arch-v32/hwregs/reg_map.h>

#include <asm/arch-v32/hwregs/intr_vect_defs.h>

#define HOOK_TRIG_ADDR     0xb7000000   /* hook cvlog model reg address */

#define HOOK_MEM_BASE_ADDR 0xa0000000   /* csp4 (shared mem) base addr */

#define HOOK_DATA(offset) ((unsigned*) HOOK_MEM_BASE_ADDR)[offset]

#define VHOOK_DATA(offset) ((volatile unsigned*) HOOK_MEM_BASE_ADDR)[offset]

#define HOOK_TRIG(funcid) do { *((unsigned *) HOOK_TRIG_ADDR) = funcid; } while(0)

#define HOOK_DATA_BYTE(offset) ((unsigned char*) HOOK_MEM_BASE_ADDR)[offset]

// ------------------------------------------------------------------ hook_call

int hook_call( unsigned id, unsigned pcnt, ...) {

  va_list ap;

  unsigned i;

  unsigned ret;

#ifdef USING_SOS

  PREEMPT_OFF_SAVE();

#endif

  // pass parameters

  HOOK_DATA(0) = id;

  /* Have to make hook_print_str a special case since we call with a

     parameter of byte type. Should perhaps be a separate

     hook_call. */

  if (id == hook_print_str) {

    int i;

    char *str;

    HOOK_DATA(1) = pcnt;

    va_start(ap, pcnt);

    str = (char*)va_arg(ap,unsigned);

    for (i=0; i!=pcnt; i++) {

      HOOK_DATA_BYTE(8+i) = str[i];

    }

    HOOK_DATA_BYTE(8+i) = 0;	/* null byte */

  }

  else {

    va_start(ap, pcnt);

    for( i = 1; i <= pcnt; i++ ) HOOK_DATA(i) = va_arg(ap,unsigned);

    va_end(ap);

  }

  // read from mem to make sure data has propagated to memory before trigging

  *((volatile unsigned*) HOOK_MEM_BASE_ADDR);

  // trigger hook

  HOOK_TRIG(id);

  // wait for call to finish

  while( VHOOK_DATA(0) > 0 ) {}

  // extract return value

  ret = VHOOK_DATA(1);

#ifdef USING_SOS

  PREEMPT_RESTORE();

#endif

  return ret;

}

unsigned

hook_buf(unsigned i)

{

  return (HOOK_DATA(i));

}

void print_str( const char *str ) {

  int i;

  for (i=1; str[i]; i++);         /* find null at end of string */

  hook_call(hook_print_str, i, str);

}

// --------------------------------------------------------------- CPU_KICK_DOG

void CPU_KICK_DOG(void) {

  (void) hook_call( hook_kick_dog, 0 );

}

// ------------------------------------------------------- CPU_WATCHDOG_TIMEOUT

void CPU_WATCHDOG_TIMEOUT( unsigned t ) {

  (void) hook_call( hook_dog_timeout, 1, t );

}

// $Id: vcs_hook.h,v 1.1 2003/08/12 12:01:06 starvik Exp $

//

// Call simulator hook functions

#ifndef HOOK_H

#define HOOK_H

int hook_call( unsigned id, unsigned pcnt, ...);

enum hook_ids {

  hook_debug_on = 1,

  hook_debug_off,

  hook_stop_sim_ok,

  hook_stop_sim_fail,

  hook_alloc_shared,

  hook_ptr_shared,

  hook_free_shared,

  hook_file2shared,

  hook_cmp_shared,

  hook_print_params,

  hook_sim_time,

  hook_stop_sim,

  hook_kick_dog,

  hook_dog_timeout,

  hook_rand,

  hook_srand,

  hook_rand_range,

  hook_print_str,

  hook_print_hex,

  hook_cmp_offset_shared,

  hook_fill_random_shared,

  hook_alloc_random_data,

  hook_calloc_random_data,

  hook_print_int,

  hook_print_uint,

  hook_fputc,

  hook_init_fd,

  hook_sbrk

};

#endif

cris_spin_lock:

	clearf	p

1:	test.d	[$r10]

1:	test.b	[$r10]

	beq	1b

	clearf	p

	ax

	clear.d [$r10]

	clear.b [$r10]

	bcs     1b

	clearf	p

	ret

cris_spin_trylock:

	clearf	p

1:	move.d	[$r10], $r11

1:	move.b	[$r10], $r11

	ax

	clear.d [$r10]

	clear.b [$r10]

        bcs	1b

        clearf	p

	ret

	move.d	$r11,$r10

	movu.b	$r11,$r10