void diu_ad_initialize(
MPC5125_DIU_AD_STRUCT_PTR ad_ptr,
uint_8 bits_comp0, uint_8 bits_comp1, uint_8 bits_comp2, uint_8 bits_comp3,
uint_8 bpp, uint_8 palette,
uint_8 red_c, uint_8 green_c, uint_8 blue_c, uint_8 alpha_c, uint_8 byte_flip,
uint_32 data_addr,
uint_16 delta_xs, uint_16 delta_ys,
uint_8 g_alpha,
uint_16 delta_xi, uint_16 delta_yi,
uint_8 flip,
uint_16 offset_xi, uint_16 offset_yi,
uint_16 offset_xd, uint_16 offset_yd,
uint_8 ckmax_r, uint_8 ckmax_g, uint_8 ckmax_b, uint_8 ckmin_r, uint_8 ckmin_g, uint_8 ckmin_b,
uint_32 nextAD)
{
ad_ptr->PIXEL_FORMAT = diu_create_ad_word0(bits_comp0, bits_comp1, bits_comp2, bits_comp3, bpp, palette, red_c, green_c, blue_c, alpha_c, byte_flip);
ad_ptr->BITMAP_ADDR = data_addr;
ad_ptr->SOURCE_SIZE = diu_create_ad_word2(delta_xs, delta_ys, g_alpha);
ad_ptr->AOI_SIZE = diu_create_ad_word3(flip, delta_xi, delta_yi);
ad_ptr->AOI_OFFSET = diu_create_ad_word4(offset_xi, offset_yi);
ad_ptr->DISPLAY_OFFSET = diu_create_ad_word5(offset_xd, offset_yd);
ad_ptr->CHROMA_KEY_MAX = diu_create_ad_word6(ckmax_r, ckmax_g, ckmax_b);
ad_ptr->CHROMA_KEY_MIN = diu_create_ad_word7(ckmin_r, ckmin_g, ckmin_b);
ad_ptr->NEXT_AD = nextAD;
ad_ptr->RESERVED_0x24 = 0x00000000;
_mem_swap_endian(diu_ad_endian_map, (pointer) ad_ptr);
}
void responder_task
(
uint32_t dummy
)
{
THE_MESSAGE_PTR msg_ptr;
_queue_id qid;
_queue_id my_qid;
puts("Receiver running...\n");
my_qid = _msgq_open(RESPONDER_QUEUE,0);
while (TRUE) {
msg_ptr = _msgq_receive(MSGQ_ANY_QUEUE,0);
if (msg_ptr != NULL) {
qid = msg_ptr->HEADER.SOURCE_QID;
msg_ptr->HEADER.SOURCE_QID = my_qid;
msg_ptr->HEADER.TARGET_QID = qid;
if (MSG_MUST_CONVERT_DATA_ENDIAN(msg_ptr->HEADER.CONTROL)) {
_mem_swap_endian(global_endian_swap_def, &msg_ptr->DATA);
MSG_SET_DATA_ENDIAN(msg_ptr->HEADER.CONTROL);
} /* Endif */
msg_ptr->DATA++;
putchar('+');
_msgq_send(msg_ptr);
} else {
puts("RESPONDER RECEIVE ERROR\n");
_task_block();
}
}
}
void _msg_swap_endian_header
(
register MESSAGE_HEADER_STRUCT_PTR message_ptr
)
{ /* Body */
_mem_swap_endian( (uchar _PTR_)_KRNL_Hdr_def, (pointer)&(message_ptr->SIZE));
message_ptr->CONTROL &= ~MSG_HDR_ENDIAN_MASK;
message_ptr->CONTROL |= MSG_HDR_ENDIAN;
} /* Endbody */
/*!
* \brief Converts the data portion of the message from intel to motorola byte
* order ( or vice versa ).
*
* The function calls _mem_swap_endian() and uses definition to swap
* single-addressable units: message_ptr + sizeof(MESSAGE_HEADER_STRUCT)
* \n The macro MSG_MUST_CONVERT_DATA_ENDIAN determines whether the data portion
* of the message needs to be converted to the other endian format.
*
* \param[in] definition Pointer to an array (NULL-terminated), each element of
* which defines the size (in single-addressable units) of fields in the data
* portion of the message.
* \param[in] message_ptr Pointer to the message whose data is to be converted.
*
* \warning Sets CONTROL in the message header to indicate the correct endian
* format for the processor.
*
* \see _mem_swap_endian
* \see MSG_MUST_CONVERT_DATA_ENDIAN
* \see MESSAGE_HEADER_STRUCT
*/
void _msg_swap_endian_data
(
uchar _PTR_ definition,
register MESSAGE_HEADER_STRUCT_PTR message_ptr
)
{ /* Body */
_mem_swap_endian( definition, (pointer)((uchar _PTR_)message_ptr +
sizeof(MESSAGE_HEADER_STRUCT)) );
message_ptr->CONTROL &= ~MSG_DATA_ENDIAN_MASK;
message_ptr->CONTROL |= MSG_DATA_ENDIAN;
} /* Endbody */
void main_task
(
uint32_t dummy
)
{
_pool_id msgpool;
THE_MESSAGE_PTR msg_ptr;
_queue_id qid;
_queue_id my_qid;
uint32_t test_number = 0;
my_qid = _msgq_open(MAIN_QUEUE,0);
qid = _msgq_get_id(TEST2_ID,RESPONDER_QUEUE);
msgpool = _msgpool_create(sizeof(THE_MESSAGE), 8, 8, 16);
while (test_number < 1000) {
msg_ptr = (THE_MESSAGE_PTR)_msg_alloc(msgpool);
msg_ptr->HEADER.TARGET_QID = qid;
msg_ptr->HEADER.SOURCE_QID = my_qid;
msg_ptr->DATA = test_number++;
putchar('-');
_msgq_send(msg_ptr);
msg_ptr = _msgq_receive(MSGQ_ANY_QUEUE, 1000);
if (msg_ptr == NULL) {
puts("Receive failed\n");
//_task_block();
} else {
if (msg_ptr->HEADER.SIZE != sizeof(THE_MESSAGE)) {
puts("Message wrong size\n");
//_task_block();
} else {
if (MSG_MUST_CONVERT_DATA_ENDIAN(msg_ptr->HEADER.CONTROL)) {
_mem_swap_endian(global_endian_swap_def, &msg_ptr->DATA);
} /* Endif */
if (msg_ptr->DATA != test_number) {
puts("Message data incorrect\n");
//_task_block();
} else {
puts("Message received\n");
}
}
_msg_free(msg_ptr);
}
}
puts("All complete\n");
_task_block();
}
_mqx_int _io_apcflash_open
(
/* [IN] the file handle for the device being opened */
FILE_DEVICE_STRUCT_PTR fd_ptr,
/* [IN] the remaining portion of the name of the device */
char _PTR_ open_name_ptr,
/* [IN] the flags to be used during operation */
char _PTR_ flags
)
{ /* Body */
APCCARD_ADDR_INFO_STRUCT addr_info;
IO_DEVICE_STRUCT_PTR io_dev_ptr = fd_ptr->DEV_PTR;
IO_PCFLASH_STRUCT_PTR info_ptr
= (IO_PCFLASH_STRUCT_PTR)io_dev_ptr->DRIVER_INIT_PTR;
ATA_IDENTIFY_DEVICE_STRUCT_PTR identify_ptr;
MQX_FILE_PTR pccard_stream = (MQX_FILE_PTR)flags;
uint_32_ptr temp_ptr;
uchar_ptr temp8_ptr;
uint_32 temp;
uint_32 error;
int_32 io_error;
uint_32 num_sectors;
uchar end_defn[] = {2, 0};
#if MQX_CHECK_ERRORS
if (pccard_stream == NULL) {
/* No PCCARD device open */
return(IO_ERROR);
} /* Endif */
#endif
/*
** Allocate a ram buffer the size of one sector to be used when
** reading/writing partial sectors -- this buffer is also used in this
** function for the identify info
*/
temp_ptr = (uint_32_ptr)_mem_alloc_system_zero(info_ptr->SECTOR_SIZE);
#if MQX_CHECK_MEMORY_ALLOCATION_ERRORS
if (temp_ptr == NULL) {
return(MQX_OUT_OF_MEMORY);
} /* Endif */
#endif
_mem_set_type(temp_ptr,MEM_TYPE_IO_SECTOR_BUFFER);
#if MQX_CHECK_ERRORS
/* Is the lower layer compatible? */
io_error = _io_ioctl(pccard_stream, IO_IOCTL_DEVICE_IDENTIFY, temp_ptr);
if ((io_error != MQX_OK) || (temp_ptr[0] != IO_DEV_TYPE_PHYS_ADV_PCCARD)) {
_mem_free(temp_ptr);
if (io_error == MQX_OK) {
io_error = IO_ERROR_DEVICE_INVALID;
}/* Endif */
return(io_error);
} /* Endif */
#endif
/* Is there a card present? */
_io_ioctl(pccard_stream, APCCARD_IOCTL_IS_CARD_INSERTED, &temp);
if ((boolean)temp == FALSE) {
_mem_free(temp_ptr);
return(IO_ERROR);
} /* Endif */
/* Wait for card to power up. This will apply Vcc and also Vpp if needed */
_io_ioctl(pccard_stream, APCCARD_IOCTL_WAIT_TILL_READY, NULL);
/* Make sure card is an ATA flash card */
/* Read CISTPL_FUNCID tuple */
temp_ptr[0] = IO_APCCARD_TUPLE_CISTPL_FUNCID;
_io_ioctl(pccard_stream, APCCARD_IOCTL_READ_TUPLE, temp_ptr);
temp8_ptr = (uchar_ptr)(temp_ptr + 1);
if (temp8_ptr[0] != 0x4) {
/* This is not a flash disk */
_mem_free(temp_ptr);
return(IO_ERROR_DEVICE_INVALID);
} /* Endif */
info_ptr->TEMP_BUFF_PTR = (uchar_ptr)temp_ptr;
/* Save the PCCard stream */
info_ptr->PCCARD_STREAM = pccard_stream;
/* Get memory locations of the flash card */
/* Register memory */
addr_info.OFFSET = ATA_REG_BASE;
addr_info.TYPE = APCCARD_COMMON_SPACE;
addr_info.BANK_SIZE = 16;
addr_info.PORT_SIZE = 8;
_io_ioctl(pccard_stream, APCCARD_IOCTL_GET_ADDR_SPACE, (pointer)&addr_info);
info_ptr->ATA_REG_PTR = (uchar_ptr)addr_info.ADDRESS;
/* Data memory */
addr_info.OFFSET = ATA_REG_BASE + ATA_DATA_BUF;
addr_info.TYPE = APCCARD_COMMON_SPACE;
addr_info.BANK_SIZE = 0x400;
addr_info.PORT_SIZE = 16;
_io_ioctl(pccard_stream, APCCARD_IOCTL_GET_ADDR_SPACE, (pointer)&addr_info);
info_ptr->ATA_DATA_PTR = (uint_16_ptr)addr_info.ADDRESS;
/* Perform a soft reset on the device */
error = _io_apcflash_reset(info_ptr);
if (error != PCFLASH_NO_ERROR) {
_io_ioctl(info_ptr->PCCARD_STREAM, APCCARD_IOCTL_POWERDOWN_CARD, NULL);
_io_ioctl(pccard_stream, APCCARD_IOCTL_FREE_ADDR_SPACE, (pointer)info_ptr->ATA_REG_PTR);
_io_ioctl(pccard_stream, APCCARD_IOCTL_FREE_ADDR_SPACE, (pointer)info_ptr->ATA_DATA_PTR);
_mem_free(temp_ptr);
return(IO_ERROR);
} /* Endif */
/* Get information about the device */
identify_ptr = (ATA_IDENTIFY_DEVICE_STRUCT_PTR)((pointer)temp_ptr);
_io_apcflash_identify_device(info_ptr, (uchar_ptr)identify_ptr);
/* Store the info in the state structure */
#if (PSP_ENDIAN == MQX_BIG_ENDIAN)
_mem_swap_endian((uchar_ptr)end_defn, &(identify_ptr->NUMBER_CYLINDERS));
_mem_swap_endian((uchar_ptr)end_defn, &(identify_ptr->SECTORS_PER_TRACK));
_mem_swap_endian((uchar_ptr)end_defn, &(identify_ptr->NUMBER_HEADS));
#endif
num_sectors = identify_ptr->NUMBER_CYLINDERS * identify_ptr->SECTORS_PER_TRACK
* identify_ptr->NUMBER_HEADS;
info_ptr->NUM_SECTORS = num_sectors;
info_ptr->SIZE = num_sectors * info_ptr->SECTOR_SIZE;
info_ptr->NUMBER_OF_HEADS = (uint_32)identify_ptr->NUMBER_HEADS;
info_ptr->NUMBER_OF_TRACKS = (uint_32)identify_ptr->NUMBER_CYLINDERS;
info_ptr->SECTORS_PER_TRACK = (uint_32)identify_ptr->SECTORS_PER_TRACK;
return(MQX_OK);
} /* Endbody */
_mqx_int FillWaveHeader(char_ptr filename, WAVE_FILE_HEADER_PTR header)
{
FILE_PTR file;
uchar def[] = {sizeof(header->CHUNK_DESCRIPTOR.ChunkSize), 0};
/* CHUNK DESCRIPTOR */
WAVE_CHUNK_DESCRIPTOR_PTR ch_des = &(header->CHUNK_DESCRIPTOR);
/* FMT SUBCHUNK */
WAVE_FMT_SUBCHUNK_PTR fmt_sch = &(header->FMT_SUBCHUNK);
/* DATA SUBCHUNK */
WAVE_DATA_SUBCHUNK_PTR data_sch = &(header->DATA_SUBCHUNK);
file = fopen(filename, "r");
if (file == NULL)
{
return(-1);
}
file_open_count ++;
/* read Chunk ID */
fread(&(ch_des->ChunkID), 1, 4, file);
ch_des->ChunkID[4] = '\0';
/* read Chunk Size */
fread(&(ch_des->ChunkSize), 1, 4, file);
_mem_swap_endian(def, &(ch_des->ChunkSize));
/* read Chunk Format */
fread(&(ch_des->Format), 1, 4, file);
ch_des->Format[4] = '\0';
/* read Sub chunk1 ID */
fread(&(fmt_sch->Subchunk1ID), 1, 4, file);
fmt_sch->Subchunk1ID[4] = '\0';
/* read Sub chunk1 Size */
fread(&(fmt_sch->Subchunk1Size), 1, 4, file);
def[0] = sizeof(fmt_sch->Subchunk1Size);
_mem_swap_endian(def, &(fmt_sch->Subchunk1Size));
/* read Audio Format */
fread(&(fmt_sch->AudioFormat), 1, 2, file);
def[0] = sizeof(fmt_sch->AudioFormat);
_mem_swap_endian(def, &(fmt_sch->AudioFormat));
/* read Num Channels */
fread(&(fmt_sch->NumChannels), 1, 2, file);
def[0] = sizeof(fmt_sch->NumChannels);
_mem_swap_endian(def, &(fmt_sch->NumChannels));
/* read Sample Rate */
fread(&(fmt_sch->SampleRate), 1, 4, file);
def[0] = sizeof(fmt_sch->SampleRate);
_mem_swap_endian(def, &(fmt_sch->SampleRate));
/* read Byte Rate */
fread(&(fmt_sch->ByteRate), 1, 4, file);
def[0] = sizeof(fmt_sch->ByteRate);
_mem_swap_endian(def, &(fmt_sch->ByteRate));
/* read Block Align */
fread(&(fmt_sch->BlockAlign), 1, 2, file);
def[0] = sizeof(fmt_sch->BlockAlign);
_mem_swap_endian(def, &(fmt_sch->BlockAlign));
/* read Bits Per Sample*/
fread(&(fmt_sch->BitsPerSample), 1, 2, file);
def[0] = sizeof(fmt_sch->BitsPerSample);
_mem_swap_endian(def, &(fmt_sch->BitsPerSample));
/* read Sub chunk2 ID*/
fread(&(data_sch->Subchunk2ID), 1, 4, file);
data_sch->Subchunk2ID[4] = '\0';
/* read Sub chunk2 Size*/
fread(&(data_sch->Subchunk2Size), 1, 4, file);
def[0] = sizeof(data_sch->Subchunk2Size);
_mem_swap_endian(def, &(data_sch->Subchunk2Size));
fclose(file);
file_open_count --;
return(0);
}
