A.3 Task.cc

A.3 Task.cc

1 // Task.cc

2

3#include "Task.hh"

4#include "TaskId.hh"

5#include "System.config"

6#include "os.hh"

7#include "SerialOut.hh"

9//-------------------------------------------------------------------------

15//=========================================================================

16extern char idle_stack;

17extern char IUS_top;

18

19Task::Task()

20: US_size(&IUS_top - &idle_stack),

21priority(0),

22name("Idle Task"),

23TaskStatus(RUN),

24next(this),

25nextWaiting(0),

26Stack(&idle_stack),

27msgQ(1),

28ExitCode(0)

29{

30TaskIDs[TASKID_IDLE] = this;

31}

32//-------------------------------------------------------------------------

33Task::Task(void (*main)(),

35unsigned short qsz,

36unsigned short prio,

38)

39: US_size(usz),

40priority(prio),

41name(taskName),

42TaskStatus(STARTED),

43nextWaiting(0),

44msgQ(qsz),

45ExitCode(0)

46{

47int i;

53Task_A0 = 0xAAAA5555; Task_A1 = 0xAAAA4444;

54Task_A2 = 0xAAAA3333; Task_A3 = 0xAAAA2222;

55Task_A4 = 0xAAAA1111; Task_A5 = 0xAAAA0000;

56Task_A6 = 0xAAAA6666;

57Task_D0 = 0xDDDD7777; Task_D1 = 0xDDDD6666;

58Task_D2 = 0xDDDD5555; Task_D3 = 0xDDDD4444;

59Task_D4 = 0xDDDD3333; Task_D5 = 0xDDDD2222;

60Task_D6 = 0xDDDD1111; Task_D7 = 0xDDDD0000;

61Task_PC = main;

62Task_CCR = 0x0000;

67if (!currTask)

68currTask = new Task();

70{

71os::INT_MASK old_INT_MASK = os::set_INT_MASK(os::NO_INTS);

72next = currTask->next;

73currTask->next = this;

74os::set_INT_MASK(old_INT_MASK);

75}

76}

77//=========================================================================

78void main()

79{

85for (Task * t = Task::currTask->next; t != Task::currTask; t = t->next)

86t->TaskStatus &= ~Task::STARTED;

96return 0; /* not reached */

97}

98//=========================================================================

99void Task::Terminate_0()

100{

101Terminate(0);

102}

103//=========================================================================

104void Task::Terminate(int ex)

105{

106{

107SerialOut so(ErrorOut);

108so.Print("\n%s Terminated", currTask->name);

109}

110currTask->ExitCode = ex;

111currTask->TaskStatus |= TERMINATED;

112Dsched();

113}

114//=========================================================================

115int Task::checkStacks()

116{

119return 0;

120}

121//

=============================================================================

122unsigned int Task::Sleep(unsigned int ticks)

123{

127{

128os::INT_MASK old_INT_MASK = os::set_INT_MASK(os::NO_INTS);

129currTask->TaskStatus |= SLEEP;

130currTask->TaskSleep = ticks;

131os::set_INT_MASK(old_INT_MASK);

132}

133Dsched();

134return ticks;

135}

136//=========================================================================

137unsigned int Task::userStackUsed() const

138{

139for (int i = 0; Stack[i] == userStackMagic; i++) /* empty */ ;

140return US_size - i;

141}

142//=========================================================================

A.4 os.hh

1 /* os.hh */

2

3 #include "Channels.hh"

4

5#ifndef __OS_HH_DEFINED__

6#define __OS_HH_DEFINED__

8extern "C" void * sbrk(unsigned long);

9template <class Type> class RingBuffer;

10template <class Type> class Queue;

11template <class Type> class Queue_Gsem;

12template <class Type> class Queue_Psem;

13template <class Type> class Queue_Gsem_Psem;

14class Semaphore;

15

16 typedef unsigned long HW_ADDRESS;

17

18class os

19{

20public:

21friend class Monitor;

22friend class SerialIn;

23friend class SerialOut;

24friend void * sbrk(unsigned long);

36static void init(INIT_LEVEL new_level);

37static int setBaudRate(Channel, int);

38static int setSerialMode(Channel, int databits, int parity);

49static INIT_LEVEL init_level;

50static void initDuart(HW_ADDRESS base, int baudA, int baudB);

51static void initChannel(HW_ADDRESS base, int baud);

52static void resetChannel(HW_ADDRESS base);

53

54static unsigned int readDuartRegister(HW_ADDRESS reg)

55{

56int result;

57asm volatile (

62return result;

63};

64

65 static void writeRegister(HW_ADDRESS reg, int val);

66

67public:

68enum INT_MASK {

73static INT_MASK set_INT_MASK(INT_MASK new_INT_MASK)

74{

75INT_MASK old_INT_MASK;

86return old_INT_MASK;

87};

88};

89

90 #endif __OS_HH_DEFINED__

91

A.5 os.cc

1/* os.cc */

2#include "System.config"

3#include "os.hh"

4#include "Task.hh"

5#include "Semaphore.hh"

6#include "SerialOut.hh"

7#include "Channels.hh"

8#include "Duart.hh"

9

10 os::INIT_LEVEL os::init_level = Not_Initialized; 11

12//=========================================================================

13//

14// functions required by libgcc2.a...

15//

16

17extern int edata;

18char * os::free_RAM = (char *)&edata;

20//-------------------------------------------------------------------------

21extern "C" void * sbrk(unsigned long size)

22{

23void * ret = os::free_RAM;

25os::free_RAM += size;

28{

29os::free_RAM -= size;

30ret = (void *) -1;

31}

41return ret;

42}

43

44//-------------------------------------------------------------------------

45extern "C" void free(void *)

46{

47}

48//-------------------------------------------------------------------------

49extern "C" void write(int, const char *text, int len)

50{

51SerialOut so(SERIAL_1);

52so.Print(text, len);

53}

54//-------------------------------------------------------------------------

55extern "C" void _exit(int ex)

56{

57Task::Terminate(ex);

58/* not reached */

59for (;;);

60}

61

62//=========================================================================

63//

64// crt0.S interface functions...

65//

66

67void os::Stop()

68{

69asm("TRAP #0");

70}

71//-------------------------------------------------------------------------

72void os::writeRegister(HW_ADDRESS reg, int v)

73{

74asm("MOVE.L %0,A0; MOVE.L %1,D0; TRAP #15" : : "g"(reg), "g"(v) : "d0","a0");

75}

76//-------------------------------------------------------------------------

77// return time since power on (or reload) in milliseconds

78//

83unsigned long long os::getSystemTime()

84{

85for (;;)

86{

87unsigned long sys_high_1 = sysTimeHi;

91// sys_low overflows every 49.86 days. If this function is

92// hit by that event (very unlikely) then it may be that

93// sys_high_1 != sys_high_2. If so, we repeat reading

94// the system time.

97unsigned long long ret = sys_high_1;

98ret <<= 32;

99return ret + sys_low;

100}

101}

102//-------------------------------------------------------------------------

103// print stack frame in case of fatal errors

104//

105void os::Panic(short * SP)

106{

107SerialOut so(SERIAL_0_POLLED);

108int i;

109

110so.Print("\n\n======================================");

111so.Print("\nFATAL ERROR STACK DUMP: SP=%8X", SP);

112so.Print("\n======================================");

113// for (i = -5; i < 0; i++)

114// so.Print("\n[SP - 0x%2X] : %4X" , -2*i, SP[i] & 0xFFFF);

118for (i = 4; i < 10; i++)

119so.Print("\n[SP + 0x%2X] : %4X" , 2*i, SP[i] & 0xFFFF);

120so.Print("\n======================================\n");

121}

122

123//=========================================================================

124//

125// hardware initialization functions...

126//

127

128void os::init(INIT_LEVEL iLevel)

129{

132if (init_level < Polled_IO)

133{

134initDuart(DUART, CSR_9600, CSR_9600);

135init_level = Polled_IO;

136}

137

138if (iLevel == Interrupt_IO && init_level < Interrupt_IO)

139{

145writeRegister(wDUART_IMR, INT_DEFAULT);

146init_level = Interrupt_IO;

147}

148}

149//-------------------------------------------------------------------------

----

150void

151os::initDuart(HW_ADDRESS base, int baudA, int baudB)

152{

153// setup outputs

154writeRegister((HW_ADDRESS)(base + w_OPCR), OPCR_DEFAULT);

156resetChannel(base + _A);

157resetChannel(base + _B);

159writeRegister(base + w_ACR, ACR_DEFAULT);

161initChannel(base + _A, baudA);

162initChannel(base + _B, baudB);

163}

164//-------------------------------------------------------------------------

165void os::resetChannel(HW_ADDRESS channel_base)

166{

171}

172//-------------------------------------------------------------------------

173void os::initChannel(HW_ADDRESS channel_base, int baud)

174{

175const HW_ADDRESS mr = channel_base + x_MR;

176const HW_ADDRESS cr = channel_base + w_CR;

177const HW_ADDRESS csr = channel_base + w_CSR;

185}

186//-------------------------------------------------------------------------

187int os::setSerialMode(Channel ch, int databits, int parity)

188{

189int mr1 = MR1_DEFAULT & ~(MR1_P_MASK | MR1_BITS_mask);

190

191switch(databits)

192{

197default: return -1;

198}

199

200switch(parity)

201{

207default: return -1;

208}

209

210switch(ch)

211{

212case SERIAL_0:

223return -1;

224}

225//-------------------------------------------------------------------------

226int os::setBaudRate(Channel ch, int baud)

227{

228int csr;

229

230switch(baud)

231{

241default: return -1;

242}

243

244 switch(ch)

248}

249return -1;

250}