/* called by c64.c:machine_specific_init */
void cartridge_init(void)
{
cart_init();
cartridge_nmi_alarm = alarm_new(maincpu_alarm_context, "Cartridge", cart_nmi_alarm_triggered, NULL);
cartridge_freeze_alarm = alarm_new(maincpu_alarm_context, "Cartridge", cart_freeze_alarm_triggered, NULL);
cartridge_int_num = interrupt_cpu_status_int_new(maincpu_int_status, "Cartridge");
}
keep_task_t alarm_subTaskHandler(packet_t *pkt)
{
switch (pkt->subTask)
{
case alarm_qty:
switch(pkt->dir)
{
case to_device:
break;
case from_device:
break;
case from_usb:
break;
case to_usb:
break;
}
break;
case alarm_first:
switch(pkt->dir)
{
case to_device:
break;
case from_device:
break;
case from_usb:
break;
case to_usb:
if(spi_ready())
{
spi_sendToDev(pkt);
return retain_task;
}
else
{
return retain_task;
}
break;
}
break;
case alarm_clear:
alarm_new(5, "Request for unclear is not implemented");
break;
default:
alarm_new(5, "Unknown Alarm Sub Task");
break;
}
return release_task;
}
void MAC_mlme_assocReq_cb(phy_trac_t trac){
short_addr_t badAddr;
security_t sec;
badAddr = 0xffff;
mac_pib_t *mpib = get_macPIB();
switch(trac){
case(TRAC_SUCCESS):
if(waiting_for_info)
{
alarm_new(9, "Successful Tx of DataReq for assocReq");
waiting_for_info = 0;
mpib->macAssociatedPANCoord = YES;
if(coordAddr.mode == MAC_SHORT_ADDRESS)
{
mpib->macCoordShortAddress = coordAddr;
}
else if(coordAddr.mode == MAC_LONG_ADDRESS)
{
mpib->macCoordExtendedAddress = coordAddr;
}
}
if(waiting_for_AssocResponce)
{
alarm_new(9,"Successful Tx of AssocReq");
add_to_time_qsm(&MAC_dataRequestCommand, &coordAddr, (Symbols_to_Time(macResponseWaitTime)));
waiting_for_AssocResponce = 0;
waiting_for_info = 1;
}
break;
case(TRAC_NO_ACK):
MAC_mlme_assocConf(MAC_NO_ACK, badAddr, &sec);
break;
case(TRAC_CHANNEL_ACCESS_FAILURE):
MAC_mlme_assocConf(MAC_ACCESS_FAILURE, badAddr, &sec);
break;
case(TRAC_INVALID):
MAC_mlme_assocConf(MAC_INVALID_ADDRESS, badAddr, &sec);
break;
case(TRAC_SUCCESS_DATA_PENDING):
break;
}
}
/*! \brief initialize the ACIA */
void myacia_init(void)
{
acia.int_num = interrupt_cpu_status_int_new(maincpu_int_status, MYACIA);
acia.alarm_tx = alarm_new(mycpu_alarm_context, MYACIA, int_acia_tx, NULL);
acia.alarm_rx = alarm_new(mycpu_alarm_context, MYACIA, int_acia_rx, NULL);
clk_guard_add_callback(mycpu_clk_guard, clk_overflow_callback, NULL);
if (acia.log == LOG_ERR) {
acia.log = log_open(MYACIA);
}
}
void vicii_irq_init(void)
{
vicii.int_num = interrupt_cpu_status_int_new(maincpu_int_status, "VICII");
vicii.raster_irq_alarm = alarm_new(maincpu_alarm_context, "VicIIRasterIrq",
vicii_irq_alarm_handler, NULL);
}
/* FIXME: hack, because 0x4000 is only ok for 1001/8050/8250.
fdc.c:fdc_do_job() adds an offset for 2040/3040/4040 by itself :-(
Why donlly get a table for that...! */
void fdc_init(drive_context_t *drv)
{
unsigned int fnum = drv->mynumber;
BYTE *buffermem = drv->cpud->drive_ram + 0x100;
BYTE *ipromp = &(drv->drive->rom[0x4000]);
char *buffer;
fdc[fnum].buffer = buffermem;
fdc[fnum].iprom = ipromp;
if (fdc_log == LOG_ERR)
fdc_log = log_open("fdc");
#ifdef FDC_DEBUG
log_message(fdc_log, "fdc_init(drive %d)", fnum);
#endif
buffer = lib_msprintf("fdc%i", drv->mynumber);
fdc[fnum].fdc_alarm = alarm_new(drv->cpu->alarm_context, buffer, int_fdc,
drv);
lib_free(buffer);
clk_guard_add_callback(drv->cpu->clk_guard, clk_overflow_callback,
uint_to_void_ptr(drv->mynumber));
}
/* Initialize the VDC emulation. */
raster_t *vdc_init(void)
{
vdc.initialized = 0;
#ifdef GP2X
vicii_setup_delay=1;
#endif
vdc.log = log_open("VDC");
vdc.raster_draw_alarm = alarm_new(maincpu_alarm_context, "VdcRasterDraw",
vdc_raster_draw_alarm_handler, NULL);
vdc_powerup();
if (init_raster() < 0)
return NULL;
vdc.force_resize = 0;
vdc.force_repaint = 0;
vdc_draw_init();
vdc.initialized = 1;
/*vdc_set_geometry();*/
resources_touch("VDCDoubleSize");
return &vdc.raster;
}
/* Initialize the TED emulation. */
raster_t *ted_init(void)
{
ted.log = log_open("TED");
ted_irq_init();
ted_fetch_init();
ted.raster_draw_alarm = alarm_new(maincpu_alarm_context, "TEDRasterDraw",
ted_raster_draw_alarm_handler, NULL);
/* For now. */
/* ted_change_timing(NULL); */
ted_timer_init();
if (init_raster() < 0) {
return NULL;
}
ted_powerup();
ted_update_video_mode(0);
ted_update_memory_ptrs(0);
ted_draw_init();
ted.initialized = 1;
clk_guard_add_callback(maincpu_clk_guard, clk_overflow_callback, NULL);
return &ted.raster;
}
void MAC_mlme_assocInd(long_addr_t *addr, mac_capibilities_t capib, security_t *sec)
{
alarm_new( 9, "I received an MAC Assoc Request");
addr = addr;
capib = capib;
sec = sec;
}
void MAC_mlme_assocRespHandler(mpdu_t *mpdu, frame_t *fr)
{
alarm_new(9, "Received an Assoc Request");
mac_pib_t *mpib = get_macPIB();
short_addr_t addr = GET_FRAME_DATA(fr->Rx_fr, 2);
uint8_t command_status = GET_FRAME_DATA(fr->Rx_fr, 1);
/* Indicate that we are attached to a network and update the device of our new
short addr. */
MAC_setAssoc(YES);
if(mpdu->source.mode == MAC_SHORT_ADDRESS)
{
mpib->macCoordShortAddress = coordAddr;
}
else if(mpdu->source.mode == MAC_LONG_ADDRESS)
{
mpib->macCoordExtendedAddress = coordAddr;
}
MAC_setShortAddr(addr);
MAC_mlme_assocConf(MAC_SUCCESS, addr, null);
}
void TM_handler(packet_t *pkt)
{
if(pkt)
{
switch(pkt->task)
{
case task_LED:
//led_subTaskHandler(pkt); I stopped this So I would not have any transmissions to the device
break;
case task_alarm:
alarm_subTaskHandler(pkt);
break;
case task_zigbee:
zigbee_subTaskHandler(pkt);
break;
default:
alarm_new(5, "Task Manager reached and unknown task %x", pkt->task);
break;
}
TM_freePacket(pkt);
}
}
void MAC_beaconHandler(mpdu_t *mpdu, frame_t *fr)
{
/* TODO: For now I am going to send the Beacon data to the PAN descriptor table I am not sure what I am going to do with that data yet
* I know that the beacon request can send more data in the payload in the future the beacon indication in the mlme will send that on up
*/
/*TODO: I need to setup a data request if I get a beacon with this address as the dest. addr */
// TODO: I need to add a Mac status with scan mode so I capture all the desc. tables only durring scans
uint8_t len;
phy_pib_t *ppib = get_phyPIB();
mac_pib_t *mpib = get_macPIB();
mac_superframe_t sf;
mac_gtsSpec_t gtsSpec;
sf = *((mac_superframe_t *)fr->Rx_fr->ptr);
fr->Rx_fr->ptr += sizeof(mac_superframe_t);
gtsSpec = *((mac_gtsSpec_t *)fr->Rx_fr->ptr);
fr->Rx_fr->ptr += sizeof(mac_gtsSpec_t);
mac_pan_descriptor_t *desc = (mac_pan_descriptor_t *)malloc(sizeof(mac_pan_descriptor_t));
desc->Coord = mpdu->source;
desc->LogicalChannel = ppib->phyCurrentChannel;
desc->ChannelPage = ppib->phyCurrentPage;
desc->GTSPermit = false; //TODO: I need to fix this I am not sure on it.
desc->LinkQuality = fr->LQI;
desc->Timestamp = fr->timestamp;
desc->SecurityFailure = 0x00;//TODO: Proper data needs to be inserted.
desc->SecurityLevel = MAC_sec_none;// TODO: Proper data needs to be inserted.
desc->KeyIdMode = 0x00;// TODO: Proper data needs to be inserted.
desc->KeySource = 0x00;// TODO: Proper data needs to be inserted.
desc->KeyIndex = 0x00;// TODO: Proper data needs to be inserted.
if(mpib->macRuntimeStatus == MAC_SCAN_IN_PROGRESS)
{
list_add(panDescriptor, desc);
alarm_new(9, "Count of Descriptor table is %i", list_length(panDescriptor));
}
MAC_mlme_beaconInd(mpdu, fr);
NWK_beacon_handler(desc, mpdu, fr);
if(mpib->macRuntimeStatus != MAC_SCAN_IN_PROGRESS)
{
free(desc);
}
// TODO: I want to add a que for the different coordinator PAN_IDs that will allow me to select a different PANid
// Or just to see what else is out there.
}//end incoming_beacon_handler
void MAC_mlme_assocReqHandler(mpdu_t *mpdu, frame_t *fr)
{
if(MAC_isPanCoord())
{
mac_capibilities_t capib = *((mac_capibilities_t *)(fr->Rx_fr->ptr));
fr->Rx_fr->ptr += sizeof(mac_capibilities_t);
alarm_new(9, "MAC Request Command Received with cap: %.2x ", (capib));
if(mpdu->source.mode != MAC_LONG_ADDRESS)
{
alarm_new(9, "Invalid source mode in an Assoc Request");
}
MAC_mlme_assocInd(&mpdu->source.extAddr, capib, &mpdu->sec);
}
}
void MAC_mlme_assocConf(mac_status_t status, short_addr_t *addr, security_t *sec)
{
alarm_new(9, "Received an Associate Confirm with the status: %x", status);
status = status;
addr = addr;
sec = sec;
}
int hardsid_open(void)
{
if (hardsid_init() < 0) {
return -1;
}
hsid_alarm = alarm_new(maincpu_alarm_context, "hardsid", hardsid_alarm_handler, 0);
hardsid_reset();
return 0;
}
int joystick_init(void)
{
joystick_alarm = alarm_new(maincpu_alarm_context, "Joystick",
joystick_latch_handler, NULL);
#ifdef COMMON_KBD
kbd_initialize_numpad_joykeys(joykeys[0]);
#endif
return joy_arch_init();
}
void led_task(packet_t *pkt)
{
switch(pkt->subTask)
{
case led_off:
LED_Off(led_pinNum(pkt->buf[0]));
alarm_new(20, "Device turned off LED %i", pkt->buf[0]);
break;
case led_on:
LED_On(led_pinNum(pkt->buf[0]));
alarm_new(20, "Device turned on LED %i", pkt->buf[0]);
break;
case led_toggle:
LED_Toggle(led_pinNum(pkt->buf[0]));
alarm_new(20, "Device toggled LED %i", pkt->buf[0]);
break;
case led_status:
break;
case led_report:
break;
}
}
/* Functions using drive context. */
void pc8477d_init(drive_context_t *drv)
{
char *name;
if (pc8477_log == LOG_ERR) {
pc8477_log = log_open("PC8477");
}
clk_guard_add_callback(drv->cpu->clk_guard, clk_overflow_callback, drv->pc8477);
name = lib_msprintf("%sEXEC", drv->pc8477->myname);
drv->pc8477->seek_alarm = alarm_new(drv->cpu->alarm_context, name, seek_alarm_handler, drv->pc8477);
lib_free(name);
}
void MAC_mlme_assocReq(addr_t *destAddr, uint32_t page, uint8_t channel, uint8_t capabilites, security_t *sec)
{
alarm_new(9, "MLME associate Request initiated");
//
MAC_setCurrentChannel(channel);
coordAddr = *destAddr;
// TODO: I need to add the security values...
// TODO: I need to set up the page methods....
MAC_setTxCB(&MAC_mlme_assocReq_cb);
MAC_assocRequestCommand(destAddr, capabilites, sec);
waiting_for_AssocResponce = 1;
MAC_setPANid(coordAddr.PANid);
}
static void init(thread_t *post_thread) {
assert(post_thread != NULL);
thread = post_thread;
vendor->set_callback(VENDOR_SET_LPM_MODE, vendor_enable_disable_callback);
vendor->send_command(VENDOR_GET_LPM_IDLE_TIMEOUT, &idle_timeout_ms);
idle_alarm = alarm_new();
if (!idle_alarm) {
LOG_ERROR(LOG_TAG, "%s could not create idle alarm.", __func__);
}
reset_state();
}
static int epyxfastload_common_attach(void)
{
if (c64export_add(&export_res_epyx) < 0) {
return -1;
}
epyxrom_alarm = alarm_new(maincpu_alarm_context, "EPYXCartRomAlarm", epyxfastload_alarm_handler, NULL);
epyxrom_alarm_time = CLOCK_MAX;
epyxfastload_io1_list_item = io_source_register(&epyxfastload_io1_device);
epyxfastload_io2_list_item = io_source_register(&epyxfastload_io2_device);
return 0;
}
void midi_init(void)
{
midi_int_num = interrupt_cpu_status_int_new(maincpu_int_status, "MIDI");
midi_alarm = alarm_new(maincpu_alarm_context, "MIDI", int_midi, NULL);
clk_guard_add_callback(maincpu_clk_guard, clk_overflow_callback, NULL);
if (midi_log == LOG_ERR) {
midi_log = log_open("MIDI");
}
mididrv_init();
midi_reset();
}
void viacore_init(via_context_t *via_context, alarm_context_t *alarm_context,
interrupt_cpu_status_t *int_status, clk_guard_t *clk_guard)
{
char *buffer;
if (via_context->log == LOG_ERR)
via_context->log = log_open(via_context->my_module_name);
buffer = lib_msprintf("%sT1", via_context->myname);
via_context->t1_alarm = alarm_new(alarm_context, buffer, viacore_intt1,
via_context);
lib_free(buffer);
buffer = lib_msprintf("%sT2", via_context->myname);
via_context->t2_alarm = alarm_new(alarm_context, buffer, viacore_intt2,
via_context);
lib_free(buffer);
via_context->int_num = interrupt_cpu_status_int_new(int_status,
via_context->myname);
clk_guard_add_callback(clk_guard, viacore_clk_overflow_callback,
via_context);
}
void riotcore_init(riot_context_t *riot_context,
alarm_context_t *alarm_context, clk_guard_t *clk_guard,
unsigned int number)
{
char *buffer;
riot_context->log = log_open(riot_context->myname);
buffer = lib_msprintf("%sT1", riot_context->myname);
riot_context->alarm = alarm_new(alarm_context, buffer, riotcore_int_riot,
riot_context);
lib_free(buffer);
clk_guard_add_callback(clk_guard, riotcore_clk_overflow_callback,
riot_context);
}
void datasette_init(void)
{
datasette_log = log_open("Datasette");
datasette_alarm = alarm_new(maincpu_alarm_context, "Datasette",
datasette_read_bit, NULL);
clk_guard_add_callback(maincpu_clk_guard, clk_overflow_callback, NULL);
datasette_cycles_per_second = machine_get_cycles_per_second();
if (!datasette_cycles_per_second) {
log_error(datasette_log,
"Cannot get cycles per second for this machine.");
datasette_cycles_per_second = 985248;
}
}
/* Initialization. */
void kbdbuf_init(int location, int plocation, int size, CLOCK mincycles)
{
int isautoload = (cmdline_get_autostart_mode() != AUTOSTART_MODE_NONE);
if (!isautoload) {
mincycles += KbdbufDelay;
}
kbdbuf_flush_alarm = alarm_new(maincpu_alarm_context, "Keybuf", kbdbuf_flush_alarm_triggered, NULL);
kbdbuf_reset(location, plocation, size, mincycles);
/* printf("kbdbuf_init cmdline_get_autostart_mode(): %d\n", cmdline_get_autostart_mode()); */
/* inject string given to -keybuf option on commandline into keyboard buffer,
except autoload/start was used, then it is postponed to after the loading */
if (!isautoload) {
kbdbuf_feed_cmdline();
}
}
void MAC_incomingFrame(frame_t *fr)
{
//mac_command_type_t command;
mac_frame_type_t type;
mac_pib_t *mpib = get_macPIB();
mpdu_t *mpdu = (mpdu_t *)malloc(sizeof(mpdu_t));
uint8_t level = MAC_breakdownFrame(mpdu, fr);
if(level)
{
alarm_new(5, "Packet got filtered at level %i", level);
free(mpdu);
return;
}
type = mpdu->fcf.MAC_fcf_Frame_Type;
/*if(MACreceiveBeaconOnly == yes)
{
if(type != MAC_BEACON)
{
free(mpdu);
return;
}
}*/
if(type == MAC_BEACON)
{
MAC_beaconHandler(mpdu, fr);
}
if(type == MAC_DATA){
MAC_mcps_dataInd(mpdu, fr);
}
if(type == MAC_ACK){
// TODO: I need to create a ack handler...
add_ack(mpdu->seq_num);
}
if(type == MAC_COMMAND)
{
MAC_commandHandler(fr, mpdu);
}//end if
}
/* Initialization. */
raster_t *vic_init(void)
{
vic.log = log_open("VIC");
vic.raster_draw_alarm = alarm_new(maincpu_alarm_context, "VicIRasterDraw",
vic_raster_draw_alarm_handler, NULL);
clk_guard_add_callback(maincpu_clk_guard, clk_overflow_callback, NULL);
vic_change_timing();
if (init_raster() < 0)
return NULL;
vic.auxiliary_color = 0;
vic.mc_border_color = 0;
vic.color_ptr = mem_ram;
vic.screen_ptr = mem_ram;
vic.chargen_ptr = vic20memrom_chargen_rom + 0x400;
/* FIXME: Where do these values come from? */
vic.light_pen.triggered = 0;
vic.light_pen.x = 87;
vic.light_pen.y = 234;
/* FIXME */
vic.char_height = 8;
vic.row_increase_line = 8;
vic.text_cols = 22;
vic.text_lines = 23;
vic_reset();
vic_draw_init();
vic_update_memory_ptrs();
vic.initialized = 1;
resources_touch("VICDoubleSize");
/*vic_resize();*/
return &vic.raster;
}
non_repeating_timer_t *non_repeating_timer_new(period_ms_t duration, alarm_callback_t cb, void *data) {
assert(cb != NULL);
non_repeating_timer_t *ret = osi_calloc(sizeof(non_repeating_timer_t));
ret->alarm = alarm_new();
if (!ret->alarm)
goto error;
ret->duration = duration;
ret->callback = cb;
ret->data = data;
return ret;
error:;
non_repeating_timer_free(ret);
return NULL;
}
void rf230_init(void)
{
//Setup SPI for Zigbee and Clear power reduction
spi_master_init(SPI_ZIGBEE);
//Setup SPI speed for Zigbee
spi_master_setup_device(SPI_ZIGBEE, &SPI_DEVICE_ZIGBEE, SPI_MODE_0,
SPI_ZIGBEE_DEFAULT_BAUDRATE, 0);
spi_enable(SPI_ZIGBEE);
radio_RF230_init();
turn_ON_CRC();
alarm_new(9, "CRC Started \0");
}
