WebSVN – HomeAutomation – Diff – /trunk/EmbeddedSoftware/AVR/AVR-Bios/bios.c


#include "bios_funs.h"
#include "avr_cfg.h"
#include <inttypes.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/wdt.h>
#include <avr/pgmspace.h>
#ifdef BIOS_UART
#include <stdio.h>
#endif
#include <string.h>
#include "flash.h"
#include "vectors.h" // Must be included after sfr_defs.h but before any ISR()
#include "mcp2515/mcp2515.h"
 
//---------------------------------------------------------------------------
// Globals
 
volatile uint32_t gMilliSecTick;
volatile uint8_t bios_msg_full;
Can_Message_t* bios_msg_ptr; // only a pointer to main-local structure to save .bss space
 
//---------------------------------------------------------------------------
// Function definitions for the exported interface
 
void reset(void) {
    //Just loop and let the watchdog reset
    cli();
    while(1);
}
 
#ifdef BIOS_UART
void bios_putchar(char c) {
    UART_PUTCHAR(c);
}
 
char bios_getchar(void) {
    char c;
    UART_GETCHAR(c)
    return c;
}
#endif
 
unsigned long timebase_get(void) {
    uint8_t sreg;
    unsigned long res;
   
    //Disable interrupts while reading tick count
    sreg=SREG;
    cli();
   
    res = gMilliSecTick;
   
    SREG=sreg;
   
    return res;
}
 
// TODO: Insert can driver's Can_Send directly in bios interface.
Can_Return_t can_send(Can_Message_t* msg) {
    return Can_Send(msg);
}
 
//---------------------------------------------------------------------------
// Function definitions for the private functions
 
#ifdef BIOS_UART
static int console_getchar(FILE *stream) {
    return bios_getchar();
}
 
static int console_putchar(char c, FILE *stream) {
    bios_putchar(c);
    return 0;
}
 
static FILE bios_stdio = FDEV_SETUP_STREAM(console_putchar, console_getchar,
                                         _FDEV_SETUP_RW);
#endif
 
//---------------------------------------------------------------------------
// Interrupt Service Routines
// Read app_vectors.h!
 
ISR(TIMEBASE_VECTOR) {
    TIMEBASE_COUNTER -= TIMEBASE_RELOAD;
    gMilliSecTick++;
    wdt_reset();
}
 
void Can_Process(Can_Message_t* msg) {
    if (!(msg->ExtendedFlag)) return;
   
 
    if ((msg->Id & CAN_MASK_CLASS) == ((uint32_t)CAN_NMT << CAN_SHIFT_CLASS)) {
        if ((msg->Id & CAN_MASK_NMT_RID) == ((uint32_t)NODE_ID << CAN_SHIFT_NMT_RID)) {
            //printf("BIOS received msg!\n");
            if ((msg->Id & CAN_MASK_NMT_TYPE)>>CAN_SHIFT_NMT_TYPE == CAN_NMT_RESET) {
                reset();
            }
            // Copy message to bios buffer if bios is done with the previous message.
            // This is also a check to see if bios is still running. When app is
            // started, bios_msg_full is never reset to 0 so the check fails and all
            // NMT communication except reset is ignored. 
            if (!(bios_msg_full)) {
                memcpy(bios_msg_ptr, msg, sizeof(Can_Message_t));
                bios_msg_full = 1;
            }
        }      
    } else if (bios->can_callback) {
        //printf("Calling app callback.\n");
        bios->can_callback(msg);
 
    }
}
 
#define BIOS_APP    1
#define BIOS_NOAPP  2
#define BIOS_PGM    3
 
int main() {
    void (*app_reset)(void) = 0;
    uint8_t bios_state;
    uint8_t nmt_type;
    uint16_t base_addr = 0;
    uint16_t offset;
    uint16_t addr;
    uint8_t len;
    uint8_t i;
    uint16_t data;
    Can_Message_t tx_msg;
    Can_Message_t bios_msg;
    bios_msg_ptr = &bios_msg;
   
#ifdef BIOS_UART
    // Setup USART for debug channel
    UART_INIT();
    stdout = &bios_stdio;
    stdin = &bios_stdio;
#endif
   
    // Initialize a suitable hardware timer to create a 1KHz interrupt.
    TIMEBASE_INIT();
   
    // Enable watchdog timer to protect against an application locking the
    // node by leaving interrupts disabled. 
    wdt_enable(WDTO_500MS);
   
    // Move interrupt vectors to start of bootloader section and enable interrupts
    IVSEL_REG = _BV(IVCE);
    IVSEL_REG = _BV(IVSEL);
    sei();
   
    if (Can_Init() != CAN_OK) reset();
   
    tx_msg.RemoteFlag = 0;
    tx_msg.ExtendedFlag = 1;
    tx_msg.Id = CAN_ID_NMT_BIOS_START;
    tx_msg.DataLength = 3;
    tx_msg.Data.words[0] = BIOS_VERSION;
           
    if (pgm_read_word(0) == 0xffff) {
        // No application in flash
        //send CAN_NMT_BIOS_START(BIOS_VERSION, 0)
        tx_msg.Data.bytes[2] = 0;
        bios_state = BIOS_NOAPP;
    } else {
        // Application exists
        //send CAN_NMT_BIOS_START(BIOS_VERSION, 1)
        tx_msg.Data.bytes[2] = 1;
        bios_state = BIOS_APP;
    }
   
    while (Can_Send(&tx_msg) != CAN_OK);
 
    tx_msg.DataLength = 2;
   
    // main loop
    while (1) {
        // Wait for message
        while (!bios_msg_full);
        nmt_type = (bios_msg.Id & CAN_MASK_NMT_TYPE)>>CAN_SHIFT_NMT_TYPE;
       
        switch (bios_state) {
        case BIOS_APP:
            if (nmt_type == CAN_NMT_START_APP) {
                app_reset(); // Will never return
            }
            // Fall through
        case BIOS_NOAPP:
            if (nmt_type == CAN_NMT_PGM_START) {
                // Set base address
                base_addr = bios_msg.Data.words[0];
                flash_init();
                //send CAN_NMT_PGM_ACK(offset)
                tx_msg.Id = CAN_ID_NMT_PGM_ACK;
                tx_msg.Data.words[0] = base_addr;
                bios_state = BIOS_PGM;
 
            }
            break;
        case BIOS_PGM:
            if (nmt_type == CAN_NMT_PGM_DATA) {
                // Set address = base address + offset
                offset = bios_msg.Data.words[0];
                addr = base_addr + offset;
                tx_msg.Data.words[0] = offset;
                // TODO: Check (addr + dlc) valid instead
                if (addr < (uint16_t)&__bios_start) { //address valid
                    //flash data at address
                    len = (bios_msg.DataLength+1)/2; // Number of words in message, rounded up.
                    for (i=1; i<len; i++) { // Skip first word (offset)
                        data = bios_msg.Data.words[i];
                        flash_write_word(addr, data);
                        addr += 2;
                    }
                    //update crc
                    //send CAN_NMT_PGM_ACK(offset)
                    tx_msg.Id = CAN_ID_NMT_PGM_ACK;
                } else {
                    //send CAN_NMT_PGM_NACK(offset)
                    tx_msg.Id = CAN_ID_NMT_PGM_NACK;
                }
            }
            if (nmt_type == CAN_NMT_PGM_END) {
                flash_flush_buffer();
                //check crc
                //tx_msg.Data.words[0] = crc;
                if (1) { //crc ok
                    //send CAN_NMT_PGM_ACK(crc)
                    tx_msg.Id = CAN_ID_NMT_PGM_ACK;
                } else {
                    //send CAN_NMT_PGM_NACK(crc)
                    tx_msg.Id = CAN_ID_NMT_PGM_NACK;
                }
                bios_state = BIOS_NOAPP;
            }
        }
        while (Can_Send(&tx_msg) != CAN_OK);
 
 
        bios_msg_full = 0; // We're done with this message, ready for the next.
    }
 
    return 0;
}
 

Rev 261	Rev 264
1	#include "bios_funs.h"	1	#include "bios_funs.h"
2	#include "avr_cfg.h"	2	#include "avr_cfg.h"
3	#include <inttypes.h>	3	#include <inttypes.h>
4	#include <avr/io.h>	4	#include <avr/io.h>
5	#include <avr/interrupt.h>	5	#include <avr/interrupt.h>
6	#include <avr/wdt.h>	6	#include <avr/wdt.h>
7	#include <avr/pgmspace.h>	7	#include <avr/pgmspace.h>
8	#ifdef BIOS_UART	8	#ifdef BIOS_UART
9	#include <stdio.h>	9	#include <stdio.h>
10	#endif	10	#endif
11	#include <string.h>	11	#include <string.h>
12	#include "flash.h"	12	#include "flash.h"
13	#include "vectors.h" // Must be included after sfr_defs.h but before any ISR()	13	#include "vectors.h" // Must be included after sfr_defs.h but before any ISR()
14	#include "mcp2515/mcp2515.h"	14	#include "mcp2515/mcp2515.h"
15		15
16	//---------------------------------------------------------------------------	16	//---------------------------------------------------------------------------
17	// Globals	17	// Globals
18		18
19	volatile uint32_t gMilliSecTick;	19	volatile uint32_t gMilliSecTick;
20	volatile uint8_t bios_msg_full;	20	volatile uint8_t bios_msg_full;
21	Can_Message_t* bios_msg_ptr; // only a pointer to main-local structure to save .bss space	21	Can_Message_t* bios_msg_ptr; // only a pointer to main-local structure to save .bss space
22		22
23	//---------------------------------------------------------------------------	23	//---------------------------------------------------------------------------
24	// Function definitions for the exported interface	24	// Function definitions for the exported interface
25		25
26	void reset(void) {	26	void reset(void) {
27	//Just loop and let the watchdog reset	27	//Just loop and let the watchdog reset
28	cli();	28	cli();
29	while(1);	29	while(1);
30	}	30	}
31		31
32	#ifdef BIOS_UART	32	#ifdef BIOS_UART
33	void bios_putchar(char c) {	33	void bios_putchar(char c) {
34	UART_PUTCHAR(c);	34	UART_PUTCHAR(c);
35	}	35	}
36		36
37	char bios_getchar(void) {	37	char bios_getchar(void) {
38	char c;	38	char c;
39	UART_GETCHAR(c)	39	UART_GETCHAR(c)
40	return c;	40	return c;
41	}	41	}
42	#endif	42	#endif
43		43
44	unsigned long timebase_get(void) {	44	unsigned long timebase_get(void) {
45	uint8_t sreg;	45	uint8_t sreg;
46	unsigned long res;	46	unsigned long res;
47		47
48	//Disable interrupts while reading tick count	48	//Disable interrupts while reading tick count
49	sreg=SREG;	49	sreg=SREG;
50	cli();	50	cli();
51		51
52	res = gMilliSecTick;	52	res = gMilliSecTick;
53		53
54	SREG=sreg;	54	SREG=sreg;
55		55
56	return res;	56	return res;
57	}	57	}
58		58
59	// TODO: Insert can driver's Can_Send directly in bios interface.	59	// TODO: Insert can driver's Can_Send directly in bios interface.
60	Can_Return_t can_send(Can_Message_t* msg) {	60	Can_Return_t can_send(Can_Message_t* msg) {
61	return Can_Send(msg);	61	return Can_Send(msg);
62	}	62	}
63		63
64	//---------------------------------------------------------------------------	64	//---------------------------------------------------------------------------
65	// Function definitions for the private functions	65	// Function definitions for the private functions
66		66
67	#ifdef BIOS_UART	67	#ifdef BIOS_UART
68	static int console_getchar(FILE *stream) {	68	static int console_getchar(FILE *stream) {
69	return bios_getchar();	69	return bios_getchar();
70	}	70	}
71		71
72	static int console_putchar(char c, FILE *stream) {	72	static int console_putchar(char c, FILE *stream) {
73	bios_putchar(c);	73	bios_putchar(c);
74	return 0;	74	return 0;
75	}	75	}
76		76
77	static FILE bios_stdio = FDEV_SETUP_STREAM(console_putchar, console_getchar,	77	static FILE bios_stdio = FDEV_SETUP_STREAM(console_putchar, console_getchar,
78	_FDEV_SETUP_RW);	78	_FDEV_SETUP_RW);
79	#endif	79	#endif
80		80
81	//---------------------------------------------------------------------------	81	//---------------------------------------------------------------------------
82	// Interrupt Service Routines	82	// Interrupt Service Routines
83	// Read app_vectors.h!	83	// Read app_vectors.h!
84		84
85	ISR(TIMEBASE_VECTOR) {	85	ISR(TIMEBASE_VECTOR) {
86	TIMEBASE_COUNTER -= TIMEBASE_RELOAD;	86	TIMEBASE_COUNTER -= TIMEBASE_RELOAD;
87	gMilliSecTick++;	87	gMilliSecTick++;
88	wdt_reset();	88	wdt_reset();
89	}	89	}
90		90
91	void Can_Process(Can_Message_t* msg) {	91	void Can_Process(Can_Message_t* msg) {
92	if (!(msg->ExtendedFlag)) return;	92	if (!(msg->ExtendedFlag)) return;
93		93
94	//applikationen ska bara ta hand om paket som inte är nmt så else:et nedan kommer om det inte är nmt enbart	-
95	if ((msg->Id & CAN_MASK_CLASS) == ((uint32_t)CAN_NMT << CAN_SHIFT_CLASS)) {	94	if ((msg->Id & CAN_MASK_CLASS) == ((uint32_t)CAN_NMT << CAN_SHIFT_CLASS)) {
96	if ((msg->Id & CAN_MASK_NMT_RID) == ((uint32_t)NODE_ID << CAN_SHIFT_NMT_RID)) {	95	if ((msg->Id & CAN_MASK_NMT_RID) == ((uint32_t)NODE_ID << CAN_SHIFT_NMT_RID)) {
97	//printf("BIOS received msg!\n");	96	//printf("BIOS received msg!\n");
98	if ((msg->Id & CAN_MASK_NMT_TYPE)>>CAN_SHIFT_NMT_TYPE == CAN_NMT_RESET) {	97	if ((msg->Id & CAN_MASK_NMT_TYPE)>>CAN_SHIFT_NMT_TYPE == CAN_NMT_RESET) {
99	reset();	98	reset();
100	}	99	}
101	// Copy message to bios buffer if bios is done with the previous message.	100	// Copy message to bios buffer if bios is done with the previous message.
102	// This is also a check to see if bios is still running. When app is	101	// This is also a check to see if bios is still running. When app is
103	// started, bios_msg_full is never reset to 0 so the check fails and all	102	// started, bios_msg_full is never reset to 0 so the check fails and all
104	// NMT communication except reset is ignored.	103	// NMT communication except reset is ignored.
105	if (!(bios_msg_full)) {	104	if (!(bios_msg_full)) {
106	memcpy(bios_msg_ptr, msg, sizeof(Can_Message_t));	105	memcpy(bios_msg_ptr, msg, sizeof(Can_Message_t));
107	bios_msg_full = 1;	106	bios_msg_full = 1;
-		107	}
108	}	108	}
109	} else if (bios->can_callback) {	109	} else if (bios->can_callback) {
110	//printf("Calling app callback.\n");	110	//printf("Calling app callback.\n");
111	bios->can_callback(msg);	111	bios->can_callback(msg);
112	}	-
113	}	112	}
114	}	113	}
115		114
116	#define BIOS_APP 1	115	#define BIOS_APP 1
117	#define BIOS_NOAPP 2	116	#define BIOS_NOAPP 2
118	#define BIOS_PGM 3	117	#define BIOS_PGM 3
119		118
120	int main() {	119	int main() {
121	void (*app_reset)(void) = 0;	120	void (*app_reset)(void) = 0;
122	uint8_t bios_state;	121	uint8_t bios_state;
123	uint8_t nmt_type;	122	uint8_t nmt_type;
124	uint16_t base_addr = 0;	123	uint16_t base_addr = 0;
125	uint16_t offset;	124	uint16_t offset;
126	uint16_t addr;	125	uint16_t addr;
127	uint8_t len;	126	uint8_t len;
128	uint8_t i;	127	uint8_t i;
129	uint16_t data;	128	uint16_t data;
130	Can_Message_t tx_msg;	129	Can_Message_t tx_msg;
131	Can_Message_t bios_msg;	130	Can_Message_t bios_msg;
132	bios_msg_ptr = &bios_msg;	131	bios_msg_ptr = &bios_msg;
133		132
134	#ifdef BIOS_UART	133	#ifdef BIOS_UART
135	// Setup USART for debug channel	134	// Setup USART for debug channel
136	UART_INIT();	135	UART_INIT();
137	stdout = &bios_stdio;	136	stdout = &bios_stdio;
138	stdin = &bios_stdio;	137	stdin = &bios_stdio;
139	#endif	138	#endif
140		139
141	// Initialize a suitable hardware timer to create a 1KHz interrupt.	140	// Initialize a suitable hardware timer to create a 1KHz interrupt.
142	TIMEBASE_INIT();	141	TIMEBASE_INIT();
143		142
144	// Enable watchdog timer to protect against an application locking the	143	// Enable watchdog timer to protect against an application locking the
145	// node by leaving interrupts disabled.	144	// node by leaving interrupts disabled.
146	wdt_enable(WDTO_500MS);	145	wdt_enable(WDTO_500MS);
147		146
148	// Move interrupt vectors to start of bootloader section and enable interrupts	147	// Move interrupt vectors to start of bootloader section and enable interrupts
149	IVSEL_REG = _BV(IVCE);	148	IVSEL_REG = _BV(IVCE);
150	IVSEL_REG = _BV(IVSEL);	149	IVSEL_REG = _BV(IVSEL);
151	sei();	150	sei();
152		151
153	if (Can_Init() != CAN_OK) reset();	152	if (Can_Init() != CAN_OK) reset();
154		153
155	tx_msg.RemoteFlag = 0;	154	tx_msg.RemoteFlag = 0;
156	tx_msg.ExtendedFlag = 1;	155	tx_msg.ExtendedFlag = 1;
157	tx_msg.Id = CAN_ID_NMT_BIOS_START;	156	tx_msg.Id = CAN_ID_NMT_BIOS_START;
158	tx_msg.DataLength = 3;	157	tx_msg.DataLength = 3;
159	tx_msg.Data.words[0] = BIOS_VERSION;	158	tx_msg.Data.words[0] = BIOS_VERSION;
160		159
161	if (pgm_read_word(0) == 0xffff) {	160	if (pgm_read_word(0) == 0xffff) {
162	// No application in flash	161	// No application in flash
163	//send CAN_NMT_BIOS_START(BIOS_VERSION, 0)	162	//send CAN_NMT_BIOS_START(BIOS_VERSION, 0)
164	tx_msg.Data.bytes[2] = 0;	163	tx_msg.Data.bytes[2] = 0;
165	bios_state = BIOS_NOAPP;	164	bios_state = BIOS_NOAPP;
166	} else {	165	} else {
167	// Application exists	166	// Application exists
168	//send CAN_NMT_BIOS_START(BIOS_VERSION, 1)	167	//send CAN_NMT_BIOS_START(BIOS_VERSION, 1)
169	tx_msg.Data.bytes[2] = 1;	168	tx_msg.Data.bytes[2] = 1;
170	bios_state = BIOS_APP;	169	bios_state = BIOS_APP;
171	}	170	}
172		171
173	while (Can_Send(&tx_msg) != CAN_OK);	172	while (Can_Send(&tx_msg) != CAN_OK);
174		173
175	tx_msg.DataLength = 2;	174	tx_msg.DataLength = 2;
176		175
177	// main loop	176	// main loop
178	while (1) {	177	while (1) {
179	// Wait for message	178	// Wait for message
180	while (!bios_msg_full);	179	while (!bios_msg_full);
181	nmt_type = (bios_msg.Id & CAN_MASK_NMT_TYPE)>>CAN_SHIFT_NMT_TYPE;	180	nmt_type = (bios_msg.Id & CAN_MASK_NMT_TYPE)>>CAN_SHIFT_NMT_TYPE;
182		181
183	switch (bios_state) {	182	switch (bios_state) {
184	case BIOS_APP:	183	case BIOS_APP:
185	if (nmt_type == CAN_NMT_START_APP) {	184	if (nmt_type == CAN_NMT_START_APP) {
186	app_reset(); // Will never return	185	app_reset(); // Will never return
187	}	186	}
188	// Fall through	187	// Fall through
189	case BIOS_NOAPP:	188	case BIOS_NOAPP:
190	if (nmt_type == CAN_NMT_PGM_START) {	189	if (nmt_type == CAN_NMT_PGM_START) {
191	// Set base address	190	// Set base address
192	base_addr = bios_msg.Data.words[0];	191	base_addr = bios_msg.Data.words[0];
193	flash_init();	192	flash_init();
194	//send CAN_NMT_PGM_ACK(offset)	193	//send CAN_NMT_PGM_ACK(offset)
195	tx_msg.Id = CAN_ID_NMT_PGM_ACK;	194	tx_msg.Id = CAN_ID_NMT_PGM_ACK;
196	tx_msg.Data.words[0] = base_addr;	195	tx_msg.Data.words[0] = base_addr;
197	bios_state = BIOS_PGM;	196	bios_state = BIOS_PGM;
198	while (Can_Send(&tx_msg) != CAN_OK);	-
199	}	197	}
200	break;	198	break;
201	case BIOS_PGM:	199	case BIOS_PGM:
202	if (nmt_type == CAN_NMT_PGM_DATA) {	200	if (nmt_type == CAN_NMT_PGM_DATA) {
203	// Set address = base address + offset	201	// Set address = base address + offset
204	offset = bios_msg.Data.words[0];	202	offset = bios_msg.Data.words[0];
205	addr = base_addr + offset;	203	addr = base_addr + offset;
206	tx_msg.Data.words[0] = offset;	204	tx_msg.Data.words[0] = offset;
207	// TODO: Check (addr + dlc) valid instead	205	// TODO: Check (addr + dlc) valid instead
208	if (addr < (uint16_t)&__bios_start) { //address valid	206	if (addr < (uint16_t)&__bios_start) { //address valid
209	//flash data at address	207	//flash data at address
210	len = (bios_msg.DataLength+1)/2; // Number of words in message, rounded up.	208	len = (bios_msg.DataLength+1)/2; // Number of words in message, rounded up.
211	for (i=1; i<len; i++) { // Skip first word (offset)	209	for (i=1; i<len; i++) { // Skip first word (offset)
212	data = bios_msg.Data.words[i];	210	data = bios_msg.Data.words[i];
213	flash_write_word(addr, data);	211	flash_write_word(addr, data);
214	addr += 2;	212	addr += 2;
215	}	213	}
216	//update crc	214	//update crc
217	//send CAN_NMT_PGM_ACK(offset)	215	//send CAN_NMT_PGM_ACK(offset)
218	tx_msg.Id = CAN_ID_NMT_PGM_ACK;	216	tx_msg.Id = CAN_ID_NMT_PGM_ACK;
219	} else {	217	} else {
220	//send CAN_NMT_PGM_NACK(offset)	218	//send CAN_NMT_PGM_NACK(offset)
221	tx_msg.Id = CAN_ID_NMT_PGM_NACK;	219	tx_msg.Id = CAN_ID_NMT_PGM_NACK;
222	}	220	}
223	}	221	}
224	if (nmt_type == CAN_NMT_PGM_END) {	222	if (nmt_type == CAN_NMT_PGM_END) {
225	flash_flush_buffer();	223	flash_flush_buffer();
226	//check crc	224	//check crc
227	//tx_msg.Data.words[0] = crc;	225	//tx_msg.Data.words[0] = crc;
228	if (1) { //crc ok	226	if (1) { //crc ok
229	//send CAN_NMT_PGM_ACK(crc)	227	//send CAN_NMT_PGM_ACK(crc)
230	tx_msg.Id = CAN_ID_NMT_PGM_ACK;	228	tx_msg.Id = CAN_ID_NMT_PGM_ACK;
231	} else {	229	} else {
232	//send CAN_NMT_PGM_NACK(crc)	230	//send CAN_NMT_PGM_NACK(crc)
233	tx_msg.Id = CAN_ID_NMT_PGM_NACK;	231	tx_msg.Id = CAN_ID_NMT_PGM_NACK;
234	}	232	}
235	bios_state = BIOS_NOAPP;	233	bios_state = BIOS_NOAPP;
-		234	}
236	}	235	}
237	while (Can_Send(&tx_msg) != CAN_OK);	236	while (Can_Send(&tx_msg) != CAN_OK);
238	}	-
239		237
240	bios_msg_full = 0; // We're done with this message, ready for the next.	238	bios_msg_full = 0; // We're done with this message, ready for the next.
241	}	239	}
242		240
243	return 0;	241	return 0;
244	}	242	}
245		243

Subversion Repositories HomeAutomation

(root)/trunk/EmbeddedSoftware/AVR/AVR-Bios/bios.c @ 264 – Rev 261 → 264