/*!
* First kernel function (after boot loader loads it to memory)
*/
void k_startup ()
{
extern console_t K_INITIAL_STDOUT, K_STDOUT;
extern console_t *k_stdout; /* console for kernel messages */
/* set initial stdout */
k_stdout = &K_INITIAL_STDOUT;
k_stdout->init (0);
/* initialize memory subsystem (needed for boot) */
k_memory_init ();
/*! start with regular initialization */
/* interrupts */
arch_init_interrupts ();
/* detect memory faults (qemu do not detect segment violations!) */
arch_register_interrupt_handler ( INT_MEM_FAULT, k_memory_fault );
arch_register_interrupt_handler ( INT_UNDEF_FAULT, k_memory_fault );
/* timer subsystem */
k_time_init ();
/* switch to default 'stdout' for kernel */
k_stdout = &K_STDOUT;
k_stdout->init (0);
kprintf ( "%s\n", system_info );
/* enable interrupts */
enable_interrupts ();
stdio_init (); /* initialize standard output devices */
/* start desired program(s) */
hello_world ();
timer ();
/* segm_fault (); */
#if ( TURN_OFF == 0 )
kprintf ( "\nSystem halted!\n" );
halt ();
#else
/* power off (if supported, or just stop if not) */
kprintf ( "Powering off\n\n" );
power_off ();
#endif
}
static void charging_screen(void)
{
unsigned int button;
const char* msg;
ide_power_enable(false); /* power down the disk, else would be spinning */
lcd_clear_display();
do
{
#ifdef ARCHOS_RECORDER
if (charge_state == CHARGING)
msg = "charging";
else if (charge_state == TOPOFF)
msg = "topoff charge";
else if (charge_state == TRICKLE)
msg = "trickle charge";
else
msg = "not charging";
#else
msg = "charging";
#endif
lcd_puts(0, 0, msg);
{
char buf[32];
int battv = battery_voltage();
snprintf(buf, sizeof(buf), "%d.%02dV %d%%",
battv / 1000, (battv % 1000) / 10, battery_level());
lcd_puts(0, 1, buf);
}
lcd_update();
button = button_get_w_tmo(HZ/2);
#ifdef BUTTON_ON
if (button == (BUTTON_ON | BUTTON_REL))
#else
if (button == (BUTTON_RIGHT | BUTTON_REL))
#endif
break; /* start */
else
{
if (usb_detect() == USB_INSERTED)
break;
else if (!charger_inserted())
power_off(); /* charger removed: power down */
}
} while (1);
}
static void hdmi_bridge_post_disable(struct drm_bridge *bridge)
{
struct hdmi_bridge *hdmi_bridge = to_hdmi_bridge(bridge);
struct hdmi *hdmi = hdmi_bridge->hdmi;
struct hdmi_phy *phy = hdmi->phy;
DBG("power down");
hdmi_set_mode(hdmi, false);
phy->funcs->powerdown(phy);
if (hdmi_bridge->power_on) {
power_off(bridge);
hdmi_bridge->power_on = false;
}
}
static int do_poweroff (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
#ifdef CONFIG_PLATFORM_HAS_PMU
struct aml_pmu_driver *pmu_driver;
pmu_driver = aml_pmu_get_driver();
if (pmu_driver && pmu_driver->pmu_power_off) {
pmu_driver->pmu_power_off();
} else {
printf("ERROR!! NO power off hooks!\n");
}
#else
power_off();
#endif
return 0;
}
int main (void) {
//TCCR0B = _BV(CS00); // no prescaler, timer running
power_on();
while(1);
while(true) {
power_on();
_delay_ms(1000);
power_off();
_delay_ms(1000);
}
}
void shutdown(void)
{
/* We need to gracefully spin down the disk to prevent clicks. */
if (ide_powered())
{
/* Make sure ATA has been initialized. */
ata_init();
/* And put the disk into sleep immediately. */
ata_sleepnow();
}
backlight_hw_off();
power_off();
}
/*!
* First kernel function (after boot loader loads it to memory)
*/
void k_startup ()
{
extern void *k_stdout; /* console for kernel messages */
/* set initial stdout */
kdevice_set_initial_stdout ();
/* initialize memory subsystem (needed for boot) */
k_memory_init ();
/*! start with regular initialization */
/* interrupts */
arch_init_interrupts ();
/* detect memory faults (qemu do not detect segment violations!) */
arch_register_interrupt_handler ( INT_MEM_FAULT, k_memory_fault, NULL );
arch_register_interrupt_handler ( INT_UNDEF_FAULT, k_memory_fault, NULL );
/* timer subsystem */
k_time_init ();
/* devices */
k_devices_init ();
/* switch to default 'stdout' for kernel */
k_stdout = k_device_open ( K_STDOUT, O_WRONLY );
kprintf ( "%s\n", system_info );
/* enable interrupts */
enable_interrupts ();
stdio_init (); /* initialize standard input & output devices */
/* starting program routine */
PROG_START_FUNC ( NULL );
#if ( TURN_OFF == 0 )
kprintf ( "\nSystem halted!\n" );
halt ();
#else
/* power off (if supported, or just stop if not) */
kprintf ( "Powering off\n\n" );
power_off ();
#endif
}
void chipset_reset(int is_cold)
{
if (is_cold) {
CPRINTS("EC triggered cold reboot");
power_off();
/* After POWER_GOOD is dropped off,
* the system will be on again
*/
power_request = POWER_REQ_ON;
} else {
CPRINTS("EC triggered warm reboot");
CPRINTS("assert GPIO_PMIC_WARM_RESET_L for %d ms",
PMIC_WARM_RESET_L_HOLD_TIME / MSEC);
set_pmic_warm_reset(1);
usleep(PMIC_WARM_RESET_L_HOLD_TIME);
set_pmic_warm_reset(0);
}
}
/*
* Monitor the presence of a charger and perform critical frequent steps
* such as running the battery voltage filter.
*/
static inline void power_thread_step(void)
{
/* If the power off timeout expires, the main thread has failed
to shut down the system, and we need to force a power off */
if (shutdown_timeout) {
shutdown_timeout -= POWER_THREAD_STEP_TICKS;
if (shutdown_timeout <= 0)
power_off();
}
#ifdef HAVE_RTC_ALARM
power_thread_rtc_process();
#endif
/*
* Do a digital exponential filter. We don't sample the battery if
* the disk is spinning unless we are in USB mode (the disk will most
* likely always be spinning in USB mode) or charging.
*/
if (!storage_disk_is_active() || usb_inserted()
#if CONFIG_CHARGING >= CHARGING_MONITOR
|| charger_input_state == CHARGER
#endif
) {
average_step();
/* update battery status every time an update is available */
battery_status_update();
}
else if (battery_percent < 8) {
average_step_low();
/* update battery status every time an update is available */
battery_status_update();
/*
* If battery is low, observe voltage during disk activity.
* Shut down if voltage drops below shutoff level and we are not
* using NiMH or Alkaline batteries.
*/
if (!shutdown_timeout && query_force_shutdown()) {
sys_poweroff();
}
}
} /* power_thread_step */
int run_all ( char *args[] )
{
int i, j, error = 0;
char *progs_to_start[] = {
"hello", "timer", "args", "uthreads", "threads", NULL };
for ( j = 0; !error && progs_to_start[j]; j++ )
for ( i = 0; !error && prog[i].func; i++ )
if ( !strcmp ( progs_to_start[j], prog[i].name ) )
if ( start_program (i) )
error = 1;
#if ( TURN_OFF == 1 )
printf ( "Powering off\n\n" );
power_off ();
#endif
return error;
}
void initNrf()
{
power_off();
CE=0;
CSN=1; //SPI标止
SCLK=0; //SPI时钟置低
delayUs(20);
SPI_Write_Read_Register(WRITE_REG + EN_AA, 0x00); // 失能接收通道0自动应答
SPI_Write_Read_Register(WRITE_REG + SETUP_RETR, 0x00); // 失能自动重发
SPI_Write_Read_Register(WRITE_REG + RF_CH, 5/*(addr[2]%10)*//*00x01*/); // 选择射频通道0x00
SPI_Write_Read_Register(WRITE_REG + RF_SETUP, 0x07); // 数据传输率1Mbps，发射功率0dBm，低噪声放大器增益
SPI_Write_Read_Register(WRITE_REG + CONFIG, 0x7e); // IRQ收发完成中断响应，16位CRC，主发送
}
int pcmcia_hardware_disable(int slot)
{
u_long reg;
debug("hardware_disable: " PCMCIA_BOARD_MSG " Slot %c\n", 'A'+slot);
/* remove all power */
power_off(slot);
debug("Disable PCMCIA buffers and assert RESET\n");
reg = 0;
reg |= __MY_PCMCIA_GCRX_CXRESET; /* active high */
reg |= NSCU_GCRX_CXOE; /* active low */
PCMCIA_PGCRX(slot) = reg;
udelay(10000);
return (0);
}
void init() {
/* Initializacja przyciskow */
// minus
DDRA &= ~KEY1;
PORTA |= KEY1;
// plus
DDRB &= ~KEY2;
PORTB |= KEY2;
/* Porty diod jako wyjscie */
LED_PORT |= LED1|LED2|LED3|LED4|LED5|LED6;
// PWN
TCCR1A |= (1<<COM1A1)|(1<<WGM11);
TCCR1B |= (1<<CS00)|(1<<CS01)|(1<<WGM12)|(1<<WGM13);
ICR1 = 256;
DDRA |= (1<<PA6);
power_off();
};
void ActuatorOutputSubmarine::special_cmd(SPECIAL_COMMAND cmd)
{
switch(cmd) {
case (SUB_POWER_ON):
power_on();
break;
case (SUB_STARTUP_SEQUENCE):
SubmarineSingleton::get_instance().set_target_yaw(get_yaw());
SubmarineSingleton::get_instance().set_target_depth(get_depth());
startup_sequence();
break;
case (SUB_MISSION_STARTUP_SEQUENCE):
mission_startup_sequence();
break;
case (SUB_POWER_OFF):
power_off();
break;
default:
break;
}
}
void error(int errortype, int error)
{
switch(errortype)
{
case EATA:
printf("ATA error: %d", error);
break;
case EDISK:
printf("No partition found");
break;
case EBOOTFILE:
printf(strerror(error));
break;
}
lcd_update();
sleep(5*HZ);
power_off();
}
void exec_command() {
command_ready=0;
uint8_t vol=0;
if (uart_rx_buffer[0]=='v') { //change volume
vol=(uart_rx_buffer[1]&0xF)*100;
vol+=(uart_rx_buffer[2]&0xF)*10;
vol+=(uart_rx_buffer[3]&0xF);
volume=vol&255;
set_volume();
write_uart_str("OK\r\n",4);
}
else if (uart_rx_buffer[0]=='o') {
if (uart_rx_buffer[1]=='n') {
power_on();
write_uart_str("OK\r\n",4);
}
else if (uart_rx_buffer[1]=='f'&&uart_rx_buffer[2]=='f') {
power_off();
write_uart_str("OK\r\n",4);
}
}
else if (uart_rx_buffer[0]=='g'&&uart_rx_buffer[1]=='e'&&uart_rx_buffer[2]=='t') {
write_uart('O');
write_uart('K');
write_uart((volume/100)+'0');
write_uart(((volume/10)%10)+'0');
write_uart((volume%10)+'0');
write_uart('\r');
write_uart('\n');
}
else {
write_uart_str("NO\r\n",4);
}
uart_rx_buffer_idx=0;
uart_rx_buffer[0]=0;
}
/* prompt user to plug USB and fix a problem */
static void prompt_usb(const char* msg1, const char* msg2)
{
int button;
lcd_clear_display();
lcd_puts(0, 0, msg1);
lcd_puts(0, 1, msg2);
#ifdef HAVE_LCD_BITMAP
lcd_puts(0, 2, "Insert USB cable");
lcd_puts(0, 3, "and fix it.");
#endif
lcd_update();
do
{
button = button_get(true);
if (button == SYS_POWEROFF)
{
power_off();
}
} while (button != SYS_USB_CONNECTED);
usb_screen();
system_reboot();
}
/*! do stuff every 1/4 second
called from clock_10ms(), do not call directly
*/
void clock_250ms() {
#ifndef NO_AUTO_IDLE
if (temp_all_zero()) {
if (steptimeout > (30 * 4)) {
power_off();
}
else {
uint8_t save_reg = SREG;
cli();
CLI_SEI_BUG_MEMORY_BARRIER();
steptimeout++;
MEMORY_BARRIER();
SREG = save_reg;
}
}
#endif
ifclock(clock_flag_1s) {
if (DEBUG_POSITION && (debug_flags & DEBUG_POSITION)) {
// current position
sersendf_P(PSTR("Pos: %ld,%ld,%ld,%ld,%lu\n"), current_position.X, current_position.Y, current_position.Z, current_position.E, current_position.F);
// target position
sersendf_P(PSTR("Dst: %ld,%ld,%ld,%ld,%lu\n"), movebuffer[mb_tail].endpoint.X, movebuffer[mb_tail].endpoint.Y, movebuffer[mb_tail].endpoint.Z, movebuffer[mb_tail].endpoint.E, movebuffer[mb_tail].endpoint.F);
// Queue
print_queue();
// newline
serial_writechar('\n');
}
// temperature
/* if (temp_get_target())
temp_print();*/
}
#ifdef TEMP_INTERCOM
start_send();
#endif
}
static void hdmi_bridge_post_disable(struct drm_bridge *bridge)
{
struct hdmi_bridge *hdmi_bridge = to_hdmi_bridge(bridge);
struct hdmi *hdmi = hdmi_bridge->hdmi;
struct hdmi_phy *phy = hdmi->phy;
#ifdef CONFIG_DRM_MSM_HDCP
if (hdmi->hdcp_ctrl)
hdmi_hdcp_ctrl_off(hdmi->hdcp_ctrl);
#endif
DBG("power down");
hdmi_set_mode(hdmi, false);
if (phy)
phy->funcs->powerdown(phy);
if (hdmi->power_on) {
power_off(bridge);
hdmi->power_on = false;
hdmi_audio_update(hdmi);
}
}
void clock_250ms() {
if (steptimeout > (30 * 4)) {
power_off();
}
else
steptimeout++;
ifclock(CLOCK_FLAG_1S) {
if (debug_flags & DEBUG_POSITION) {
// current position
sersendf_P(PSTR("Pos: %ld,%ld,%ld,%ld,%lu\n"), current_position.X, current_position.Y, current_position.Z, current_position.E, current_position.F);
// target position
sersendf_P(PSTR("Dst: %ld,%ld,%ld,%ld,%lu\n"), movebuffer[mb_tail].endpoint.X, movebuffer[mb_tail].endpoint.Y, movebuffer[mb_tail].endpoint.Z, movebuffer[mb_tail].endpoint.E, movebuffer[mb_tail].endpoint.F);
// Queue
print_queue();
}
// temperature
/* if (temp_get_target())
temp_print();*/
}
}
int main(void)
{
if (BLE_init_dev() == 1) {
return 1;
}
/* Initialize */
init();
TZ01_system_init();
TZ01_console_init();
if (!MPU9250_drv_sleep(&Driver_SPI3)) {
TZ01_console_puts("MPU9250_drv_sleep() failed.\r\n");
}
for (;;) {
TZ01_system_run();
if (check_uvd()) {
/* 電圧低下検出 */
Driver_GPIO.WritePin(10, 1);
if (BLE_main(true) != 0) {
/* 定電圧検出から10秒経った */
break;
}
} else {
/* 通常動作 */
Driver_GPIO.WritePin(10, 0);
BLE_main(false);
}
}
term:
BLE_stop();
TZ01_console_puts("Program terminated.\r\n");
power_off();
return 0;
}
enum power_state power_handle_state(enum power_state state)
{
int value;
static int boot_from_g3;
switch (state) {
case POWER_G3:
boot_from_g3 = check_for_power_on_event();
if (boot_from_g3)
return POWER_G3S5;
break;
case POWER_G3S5:
return POWER_S5;
case POWER_S5:
if (boot_from_g3) {
value = boot_from_g3;
boot_from_g3 = 0;
} else {
value = check_for_power_on_event();
}
if (value) {
CPRINTS("power on %d", value);
return POWER_S5S3;
}
return state;
case POWER_S5S3:
hook_notify(HOOK_CHIPSET_PRE_INIT);
power_on();
disable_sleep(SLEEP_MASK_AP_RUN);
powerled_set_state(POWERLED_STATE_ON);
if (power_wait_signals(IN_POWER_GOOD) == EC_SUCCESS) {
CPRINTS("POWER_GOOD seen");
if (power_button_wait_for_release(
DELAY_SHUTDOWN_ON_POWER_HOLD) ==
EC_SUCCESS) {
power_button_was_pressed = 0;
set_pmic_pwron(0);
/* setup misc gpio for S3/S0 functionality */
gpio_set_flags(GPIO_SUSPEND_L, GPIO_INPUT
| GPIO_INT_BOTH | GPIO_PULL_DOWN);
gpio_set_flags(GPIO_EC_INT_L, GPIO_OUTPUT
| GPIO_OUT_HIGH);
/* Call hooks now that AP is running */
hook_notify(HOOK_CHIPSET_STARTUP);
return POWER_S3;
} else {
CPRINTS("long-press button, shutdown");
power_off();
/*
* Since the AP may be up already, return S0S3
* state to go through the suspend hook.
*/
return POWER_S0S3;
}
} else {
CPRINTS("POWER_GOOD not seen in time");
}
chipset_turn_off_power_rails();
return POWER_S5;
case POWER_S3:
if (!(power_get_signals() & IN_POWER_GOOD))
return POWER_S3S5;
else if (!(power_get_signals() & IN_SUSPEND))
return POWER_S3S0;
return state;
case POWER_S3S0:
powerled_set_state(POWERLED_STATE_ON);
hook_notify(HOOK_CHIPSET_RESUME);
return POWER_S0;
case POWER_S0:
value = check_for_power_off_event();
if (value) {
CPRINTS("power off %d", value);
power_off();
return POWER_S0S3;
} else if (power_get_signals() & IN_SUSPEND)
return POWER_S0S3;
return state;
case POWER_S0S3:
if (lid_is_open())
powerled_set_state(POWERLED_STATE_SUSPEND);
else
powerled_set_state(POWERLED_STATE_OFF);
/* Call hooks here since we don't know it prior to AP suspend */
hook_notify(HOOK_CHIPSET_SUSPEND);
return POWER_S3;
case POWER_S3S5:
power_button_wait_for_release(-1);
power_button_was_pressed = 0;
return POWER_S5;
case POWER_S5G3:
return POWER_G3;
}
return state;
}
void _ISR _INT3Interrupt(void) {
_INT3IF = 0;
_INT3IE = 0; // ack & disable
// Poweroff softirq
power_off(NULL);
}
int main( int argc, char **argv )
{
int32_t ret;
char optstring[OPTSTRING_LEN];
int opt;
int opt_preferred = 0;
int opt_explicit = 0;
int opt_sdtvon = 0;
int opt_off = 0;
int opt_modes = 0;
int opt_monitor = 0;
int opt_status = 0;
int opt_audiosup = 0;
int opt_dumpedid = 0;
int opt_showinfo = 0;
int opt_3d = 0;
int opt_json = 0;
int opt_name = 0;
char *dumpedid_filename = NULL;
VCHI_INSTANCE_T vchi_instance;
VCHI_CONNECTION_T *vchi_connection;
HDMI_RES_GROUP_T power_on_explicit_group = HDMI_RES_GROUP_INVALID;
uint32_t power_on_explicit_mode;
uint32_t power_on_explicit_drive = HDMI_MODE_HDMI;
HDMI_RES_GROUP_T get_modes_group = HDMI_RES_GROUP_INVALID;
SDTV_MODE_T sdtvon_mode;
SDTV_ASPECT_T sdtvon_aspect;
// Initialize VCOS
vcos_init();
// Create the option string that we will be using to parse the arguments
create_optstring( optstring );
// Parse the command line arguments
while (( opt = getopt_long_only( argc, argv, optstring, long_opts,
NULL )) != -1 )
{
switch ( opt )
{
case 0:
{
// getopt_long returns 0 for entries where flag is non-NULL
break;
}
case OPT_PREFERRED:
{
opt_preferred = 1;
break;
}
case OPT_EXPLICIT:
{
char group_str[32], drive_str[32];
/* coverity[secure_coding] String length specified, so can't overflow */
int s = sscanf( optarg, "%31s %u %31s", group_str, &power_on_explicit_mode, drive_str );
if ( s != 2 && s != 3 )
{
LOG_ERR( "Invalid arguments '%s'", optarg );
goto err_out;
}
// Check the group first
if ( vcos_strcasecmp( "CEA", group_str ) == 0 )
{
power_on_explicit_group = HDMI_RES_GROUP_CEA;
}
else if ( vcos_strcasecmp( "DMT", group_str ) == 0 )
{
power_on_explicit_group = HDMI_RES_GROUP_DMT;
}
else if ( vcos_strcasecmp( "CEA_3D", group_str ) == 0 ||
vcos_strcasecmp( "CEA_3D_SBS", group_str ) == 0)
{
power_on_explicit_group = HDMI_RES_GROUP_CEA;
opt_3d = 1;
}
else if ( vcos_strcasecmp( "CEA_3D_TB", group_str ) == 0 )
{
power_on_explicit_group = HDMI_RES_GROUP_CEA;
opt_3d = 2;
}
else
{
LOG_ERR( "Invalid group '%s'", group_str );
goto err_out;
}
if (s==3)
{
if (vcos_strcasecmp( "HDMI", drive_str ) == 0 )
{
power_on_explicit_drive = HDMI_MODE_HDMI;
}
else if (vcos_strcasecmp( "DVI", drive_str ) == 0 )
{
power_on_explicit_drive = HDMI_MODE_DVI;
}
else
{
LOG_ERR( "Invalid drive '%s'", drive_str );
goto err_out;
}
}
// Then check if mode is a sane number
if ( power_on_explicit_mode > MAX_MODE_ID )
{
LOG_ERR( "Invalid mode '%u'", power_on_explicit_mode );
goto err_out;
}
opt_explicit = 1;
break;
}
case OPT_SDTVON:
{
char mode_str[32], aspect_str[32];
if ( sscanf( optarg, "%s %s", mode_str,
aspect_str ) != 2 )
{
LOG_ERR( "Invalid arguments '%s'", optarg );
goto err_out;
}
// Check the group first
if ( vcos_strcasecmp( "NTSC", mode_str ) == 0 )
{
sdtvon_mode = SDTV_MODE_NTSC;
}
else if ( vcos_strcasecmp( "NTSC_J", mode_str ) == 0 )
{
sdtvon_mode = SDTV_MODE_NTSC_J;
}
else if ( vcos_strcasecmp( "PAL", mode_str ) == 0 )
{
sdtvon_mode = SDTV_MODE_PAL;
}
else if ( vcos_strcasecmp( "PAL_M", mode_str ) == 0 )
{
sdtvon_mode = SDTV_MODE_PAL_M;
}
else
{
LOG_ERR( "Invalid mode '%s'", mode_str );
goto err_out;
}
if ( vcos_strcasecmp( "4:3", aspect_str ) == 0 )
{
sdtvon_aspect = SDTV_ASPECT_4_3;
}
else if ( vcos_strcasecmp( "14:9", aspect_str ) == 0 )
{
sdtvon_aspect = SDTV_ASPECT_14_9;
}
else if ( vcos_strcasecmp( "16:9", aspect_str ) == 0 )
{
sdtvon_aspect = SDTV_ASPECT_16_9;
}
opt_sdtvon = 1;
break;
}
case OPT_OFF:
{
opt_off = 1;
break;
}
case OPT_MODES:
{
if ( vcos_strcasecmp( "CEA", optarg ) == 0 )
{
get_modes_group = HDMI_RES_GROUP_CEA;
}
else if ( vcos_strcasecmp( "DMT", optarg ) == 0 )
{
get_modes_group = HDMI_RES_GROUP_DMT;
}
else
{
LOG_ERR( "Invalid group '%s'", optarg );
goto err_out;
}
opt_modes = 1;
break;
}
case OPT_MONITOR:
{
opt_monitor = 1;
break;
}
case OPT_STATUS:
{
opt_status = 1;
break;
}
case OPT_AUDIOSUP:
{
opt_audiosup = 1;
break;
}
case OPT_DUMPEDID:
{
opt_dumpedid = 1;
dumpedid_filename = optarg;
break;
}
case OPT_SHOWINFO:
{
opt_showinfo = atoi(optarg)+1;
break;
}
case OPT_JSON:
{
opt_json = 1;
break;
}
case OPT_NAME:
{
opt_name = 1;
break;
}
default:
{
LOG_ERR( "Unrecognized option '%d'\n", opt );
goto err_usage;
}
case '?':
case OPT_HELP:
{
goto err_usage;
}
} // end switch
} // end while
argc -= optind;
argv += optind;
if (( optind == 1 ) || ( argc > 0 ))
{
if ( argc > 0 )
{
LOG_ERR( "Unrecognized argument -- '%s'", *argv );
}
goto err_usage;
}
if (( opt_preferred + opt_explicit + opt_sdtvon > 1 ))
{
LOG_ERR( "Conflicting power on options" );
goto err_usage;
}
if ((( opt_preferred == 1 ) || ( opt_explicit == 1 ) || ( opt_sdtvon == 1)) && ( opt_off == 1 ))
{
LOG_ERR( "Cannot power on and power off simultaneously" );
goto err_out;
}
// Initialize the VCHI connection
ret = vchi_initialise( &vchi_instance );
if ( ret != 0 )
{
LOG_ERR( "Failed to initialize VCHI (ret=%d)", ret );
goto err_out;
}
ret = vchi_connect( NULL, 0, vchi_instance );
if ( ret != 0)
{
LOG_ERR( "Failed to create VCHI connection (ret=%d)", ret );
goto err_out;
}
// LOG_INFO( "Starting tvservice" );
// Initialize the tvservice
vc_vchi_tv_init( vchi_instance, &vchi_connection, 1 );
if ( opt_monitor == 1 )
{
LOG_STD( "Starting to monitor for HDMI events" );
if ( start_monitor() != 0 )
{
goto err_stop_service;
}
}
if ( opt_modes == 1 )
{
if ( get_modes( get_modes_group, opt_json ) != 0 )
{
goto err_stop_service;
}
}
if ( opt_preferred == 1 )
{
if ( power_on_preferred() != 0 )
{
goto err_stop_service;
}
}
else if ( opt_explicit == 1 )
{
//Distinguish between turning on 3D side by side and 3D top/bottom
if(opt_3d == 1 && set_property( HDMI_PROPERTY_3D_STRUCTURE, HDMI_3D_FORMAT_SBS_HALF, 0) != 0)
{
goto err_stop_service;
}
else if(opt_3d == 2 && set_property( HDMI_PROPERTY_3D_STRUCTURE, HDMI_3D_FORMAT_TB_HALF, 0) != 0)
{
goto err_stop_service;
}
if ( power_on_explicit( power_on_explicit_group,
power_on_explicit_mode, power_on_explicit_drive ) != 0 )
{
goto err_stop_service;
}
}
else if ( opt_sdtvon == 1 )
{
if ( power_on_sdtv( sdtvon_mode,
sdtvon_aspect ) != 0 )
{
goto err_stop_service;
}
}
else if (opt_off == 1 )
{
if ( power_off() != 0 )
{
goto err_stop_service;
}
}
if ( opt_status == 1 )
{
if ( get_status() != 0 )
{
goto err_stop_service;
}
}
if ( opt_audiosup == 1 )
{
if ( get_audiosup() != 0 )
{
goto err_stop_service;
}
}
if ( opt_dumpedid == 1 )
{
if ( dump_edid(dumpedid_filename) != 0 )
{
goto err_stop_service;
}
}
if ( opt_showinfo )
{
if ( show_info(opt_showinfo-1) != 0 )
{
goto err_stop_service;
}
}
if ( opt_name == 1 )
{
TV_DEVICE_ID_T id;
memset(&id, 0, sizeof(id));
if(vc_tv_get_device_id(&id) == 0) {
if(id.vendor[0] == '\0' || id.monitor_name[0] == '\0') {
LOG_ERR( "No device present" );
} else {
LOG_STD( "device_name=%s-%s", id.vendor, id.monitor_name);
}
} else {
LOG_ERR( "Failed to obtain device name" );
}
}
if ( opt_monitor == 1 )
{
// Wait until we get the signal to exit
vcos_event_wait( &quit_event );
vcos_event_delete( &quit_event );
}
err_stop_service:
// LOG_INFO( "Stopping tvservice" );
// Stop the tvservice
vc_vchi_tv_stop();
// Disconnect the VCHI connection
vchi_disconnect( vchi_instance );
exit( 0 );
err_usage:
show_usage();
err_out:
exit( 1 );
}
void set_power(void) {
saved = 0;
if(state == 0) power_off();
else if(state >= 1) power_on();
OCR1A=state*43;
};
int get_command(pState state){
//magic len command subcommand data checkval
//message is len + 8 (2 magic, 2 len, 4 checkval)
//magic = 0xa55a, short len, short command, var subcommand, var data, int checkval
// unsigned char *buf = malloc(MAX_MESSAGE_LEN+8);
unsigned char buf[MAX_MESSAGE_LEN+8];
unsigned int checkval = 0;
unsigned int calc_checkval = 0;
unsigned short magic = 0;
unsigned short len = 0;
unsigned short command = 0xaa;
unsigned short subcommand = 0xffff;
unsigned short sensorID = 0xffff;
unsigned int sensor_address = 0xffff;
unsigned int coefficient = 0xffff;
unsigned short temp = 0xffff;
unsigned short numSteps = 0xffff;
unsigned short *tempP = NULL;
unsigned short seconds = 0;
pStep steps = NULL;
int ret = -1;
unsigned int fw = 0;
bzero(buf,MAX_MESSAGE_LEN+8);
//get magic
get_bytes(buf ,2);
magic = get_short(buf);
if (magic != MAGIC){
prime_buf(buf);
send(buf,12);
//free(buf);
return 1;
}
//get len
get_bytes(buf+2,2);
len = get_short(buf+2);
//check len
if (len > MAX_MESSAGE_LEN){
prime_buf(buf);
send(buf,12);
//free(buf);
return 1;
}
//get the rest of message except checkval
get_bytes(buf+4, len);
//get checkval
checkval = get_int(buf+len);
//compare to calculated from message
calc_checkval = check_val( buf, len);
if ( checkval != calc_checkval ){
//bad check_val
prime_buf(buf);
send(buf,12);
//free(buf);
return 1;
}
//get command
command = get_short(buf+4);
switch (command) {
case 1:{ //set power state
subcommand = get_short(buf+6);
prime_buf(buf);
if (subcommand == 0x0000){
power_off(state);
}
if (subcommand == 0x0001){
power_on(state);
}
if (subcommand > 0x0001){
//bad subcommand
}
send(buf, 12);
break;
}
case 2:{//set temp
temp = get_short(buf+6);
prime_buf(buf);
if (set_temp(state,temp) == 2){
buf[6] = 1;
}
send(buf, 12);
break;
}
case 3:{ //add sensor
sensorID = get_short(buf+6);
sensor_address = get_int(buf+8);
coefficient = get_int(buf+12);
unsigned int sensorTemp = get_int(buf+16);
//check count < 10 buf[6] = 0x08, sensor_ID is unique/not in use buf[6] = 0x07,
ret = add_sensor(state, sensorID, sensor_address, coefficient, sensorTemp);
prime_buf(buf);
if (ret == 2){buf[6]=0x07;}
if (ret == 3){buf[6]=0x08;}
send(buf, 12);
break;
}
case 4:{ //remove sensor
sensorID = get_short(buf+6);
ret = remove_sensor(state,sensorID);
prime_buf(buf);
if (ret == 1){buf[6]=0x06;}
send(buf, 12);
break;
}
case 5:{ //set smoke sensor
subcommand = get_short(buf+6);
prime_buf(buf);
if (subcommand == 0x0000){
smoke_off(state);
}
if (subcommand == 0x0001){
smoke_on(state);
}
if (subcommand > 0x0001){
//bad subcommand
//no response
}
send(buf, 12);
break;
}
case 6:{ //set program
numSteps = get_short(buf+6);
steps = (pStep)(buf+8) ;
ret = add_steps(state,numSteps,steps);
prime_buf(buf);
if (ret == 3){buf[6]=3;}
if (ret == 2){buf[6]=2;}
if (ret == 1){buf[6]=1;}
send(buf, 12);
break;
}
case 7:{//get program
prime_buf(buf);
unsigned int lenz = 0;
unsigned int program[30];
bzero(program,120);
buf[4]=1;
buf[6]=7;
get_program(state, &lenz, program);
lenz = lenz*3*sizeof(int);
cgc_memcpy(buf+8,&lenz,sizeof(int));
cgc_memcpy(buf+12,program,lenz);
send(buf,lenz + 12);
break;
}
case 8:{//get status
prime_buf(buf);
buf[4]=1;
buf[6]=8;
unsigned int status[6];
int len = 24;
ret = get_status(state,status);
cgc_memcpy(buf+8,&len,sizeof(int));
cgc_memcpy(buf+12,status,24);
send(buf,36);
break;
}
case 9:{//simulate seconds
seconds = get_short(buf+6);
prime_buf(buf);
unsigned int bufsize = 12;
unsigned int histSize = 0;
ret = simulate_seconds(state, seconds);
unsigned int currentTime = state->currentTime;
unsigned int setTemp = state->setTemp;
if (ret == 0 ){
buf[6] = 9;
cgc_memcpy(buf+8, ¤tTime ,sizeof(int));
send(buf,12);
}
if(ret == 2){
buf[4] = 1;
buf[6] = 0xc;
histSize = state->historyPosition*sizeof(int);
unsigned int *pHistoryList = state->history;
unsigned int historyListSize = state->historyPosition;
unsigned int ambientTemp = state->ambientTemp;
new_state(state);
if (historyListSize > 0){
cgc_memcpy(buf+8, &historyListSize, sizeof(historyListSize));
cgc_memcpy(buf+12, pHistoryList, histSize);
bufsize = histSize + 12;
}
cgc_memcpy(buf+bufsize, &ambientTemp, sizeof(unsigned int));
bufsize+=4;
cgc_memcpy(buf+bufsize, &setTemp, sizeof(unsigned int));
bufsize+=4;
send(buf, bufsize);
//new_state(state);
}
break;
}
case 0xa:{ //validate firmware
unsigned int fw = validate_fw(state);
prime_buf(buf);
buf[4]=1;
buf[6]=0xa;
buf[8]=4;
cgc_memcpy(buf+12, &fw,sizeof(int) );
send(buf, 16);
break;
}
case 0xb:{//cgc_read sensor list
prime_buf(buf);
int len = 0;
buf[4]=1;
buf[6]=0xb;
len = state->sensorCount * (sizeof(int)*4);
//buff is filled with sensor bytes
unsigned int sensorList[40*sizeof(int)];
get_sensors(state,sensorList);
cgc_memcpy(buf+8,&len,sizeof(int));
cgc_memcpy(buf+12,sensorList,len);
send(buf, len+12);
break;
}
case 0xc:{//set ambient temp
int ambientTemp = get_signed_int(buf+6);
prime_buf(buf);
if (set_ambient_temp(state,ambientTemp) == 2){
buf[6] = 1;
}
send(buf, 12);
break;
}
case 0xff:{
//free(buf);
exit_normal();
break;
}
default:{
//bad command
prime_buf(buf);
buf[6]=5;
send(buf,12);
break;
}
}
// free(buf);
return 0;
}
/// initialise all I/O - set pins as input or output, turn off unused subsystems, etc
void io_init(void) {
// disable modules we don't use
#ifdef PRR
PRR = MASK(PRTWI) | MASK(PRADC) | MASK(PRSPI);
#elif defined PRR0
PRR0 = MASK(PRTWI) | MASK(PRADC) | MASK(PRSPI);
#if defined(PRUSART3)
// don't use USART2 or USART3- leave USART1 for GEN3 and derivatives
PRR1 |= MASK(PRUSART3) | MASK(PRUSART2);
#endif
#if defined(PRUSART2)
// don't use USART2 or USART3- leave USART1 for GEN3 and derivatives
PRR1 |= MASK(PRUSART2);
#endif
#endif
ACSR = MASK(ACD);
// setup I/O pins
// X Stepper
//WRITE(X_STEP_PIN, 0); SET_OUTPUT(X_STEP_PIN);
//WRITE(X_DIR_PIN, 0); SET_OUTPUT(X_DIR_PIN);
#ifdef X_MIN_PIN
SET_INPUT(X_MIN_PIN);
WRITE(X_MIN_PIN, 0); // pullup resistors off
#endif
#ifdef X_MAX_PIN
SET_INPUT(X_MAX_PIN);
WRITE(X_MAX_PIN, 0); // pullup resistors off
#endif
// Y Stepper
//WRITE(Y_STEP_PIN, 0); SET_OUTPUT(Y_STEP_PIN);
//WRITE(Y_DIR_PIN, 0); SET_OUTPUT(Y_DIR_PIN);
#ifdef Y_MIN_PIN
SET_INPUT(Y_MIN_PIN);
WRITE(Y_MIN_PIN, 0); // pullup resistors off
#endif
#ifdef Y_MAX_PIN
SET_INPUT(Y_MAX_PIN);
WRITE(Y_MAX_PIN, 0); // pullup resistors off
#endif
// Z Stepper
#if defined Z_STEP_PIN && defined Z_DIR_PIN
WRITE(Z_STEP_PIN, 0); SET_OUTPUT(Z_STEP_PIN);
WRITE(Z_DIR_PIN, 0); SET_OUTPUT(Z_DIR_PIN);
#endif
#ifdef Z_MIN_PIN
SET_INPUT(Z_MIN_PIN);
WRITE(Z_MIN_PIN, 0); // pullup resistors off
#endif
#ifdef Z_MAX_PIN
SET_INPUT(Z_MAX_PIN);
WRITE(Z_MAX_PIN, 0); // pullup resistors off
#endif
#if defined E_STEP_PIN && defined E_DIR_PIN
WRITE(E_STEP_PIN, 0); SET_OUTPUT(E_STEP_PIN);
WRITE(E_DIR_PIN, 0); SET_OUTPUT(E_DIR_PIN);
#endif
// Common Stepper Enable
#ifdef STEPPER_ENABLE_PIN
#ifdef STEPPER_INVERT_ENABLE
WRITE(STEPPER_ENABLE_PIN, 0);
#else
WRITE(STEPPER_ENABLE_PIN, 1);
#endif
SET_OUTPUT(STEPPER_ENABLE_PIN);
#endif
// X Stepper Enable
#ifdef X_ENABLE_PIN
#ifdef X_INVERT_ENABLE
WRITE(X_ENABLE_PIN, 0);
#else
WRITE(X_ENABLE_PIN, 1);
#endif
SET_OUTPUT(X_ENABLE_PIN);
#endif
// Y Stepper Enable
#ifdef Y_ENABLE_PIN
#ifdef Y_INVERT_ENABLE
WRITE(Y_ENABLE_PIN, 0);
#else
WRITE(Y_ENABLE_PIN, 1);
#endif
SET_OUTPUT(Y_ENABLE_PIN);
#endif
// Z Stepper Enable
#ifdef Z_ENABLE_PIN
#ifdef Z_INVERT_ENABLE
WRITE(Z_ENABLE_PIN, 0);
#else
WRITE(Z_ENABLE_PIN, 1);
#endif
SET_OUTPUT(Z_ENABLE_PIN);
#endif
// E Stepper Enable
#ifdef E_ENABLE_PIN
#ifdef E_INVERT_ENABLE
WRITE(E_ENABLE_PIN, 0);
#else
WRITE(E_ENABLE_PIN, 1);
#endif
SET_OUTPUT(E_ENABLE_PIN);
#endif
#ifdef STEPPER_ENABLE_PIN
power_off();
#endif
#ifdef TEMP_MAX6675
// setup SPI
WRITE(SCK, 0); SET_OUTPUT(SCK);
WRITE(MOSI, 1); SET_OUTPUT(MOSI);
WRITE(MISO, 1); SET_INPUT(MISO);
WRITE(SS, 1); SET_OUTPUT(SS);
#endif
#ifdef TEMP_INTERCOM
// Enable the RS485 transceiver
SET_OUTPUT(RX_ENABLE_PIN);
SET_OUTPUT(TX_ENABLE_PIN);
WRITE(RX_ENABLE_PIN,0);
disable_transmit();
#endif
}
static void button_tick(void)
{
static int count = 0;
static int repeat_speed = REPEAT_INTERVAL_START;
static int repeat_count = 0;
static bool repeat = false;
static bool post = false;
#ifdef HAVE_BACKLIGHT
static bool skip_release = false;
#ifdef HAVE_REMOTE_LCD
static bool skip_remote_release = false;
#endif
#endif
int diff;
int btn;
#ifdef HAVE_BUTTON_DATA
int data = 0;
#else
const int data = 0;
#endif
#if defined(HAS_SERIAL_REMOTE) && !defined(SIMULATOR)
/* Post events for the remote control */
btn = remote_control_rx();
if(btn)
button_try_post(btn, 0);
#endif
#ifdef HAVE_BUTTON_DATA
btn = button_read(&data);
#else
btn = button_read();
#endif
#if defined(HAVE_HEADPHONE_DETECTION)
if (headphones_inserted() != phones_present)
{
/* Use the autoresetting oneshot to debounce the detection signal */
phones_present = !phones_present;
timeout_register(&hp_detect_timeout, btn_detect_callback,
HZ/2, phones_present);
}
#endif
/* Find out if a key has been released */
diff = btn ^ lastbtn;
if(diff && (btn & diff) == 0)
{
#ifdef HAVE_BACKLIGHT
#ifdef HAVE_REMOTE_LCD
if(diff & BUTTON_REMOTE)
if(!skip_remote_release)
button_try_post(BUTTON_REL | diff, data);
else
skip_remote_release = false;
else
#endif
if(!skip_release)
button_try_post(BUTTON_REL | diff, data);
else
skip_release = false;
#else
button_try_post(BUTTON_REL | diff, data);
#endif
}
else
{
if ( btn )
{
/* normal keypress */
if ( btn != lastbtn )
{
post = true;
repeat = false;
repeat_speed = REPEAT_INTERVAL_START;
}
else /* repeat? */
{
if ( repeat )
{
if (!post)
count--;
if (count == 0) {
post = true;
/* yes we have repeat */
if (repeat_speed > REPEAT_INTERVAL_FINISH)
repeat_speed--;
count = repeat_speed;
repeat_count++;
/* Send a SYS_POWEROFF event if we have a device
which doesn't shut down easily with the OFF
key */
#ifdef HAVE_SW_POWEROFF
if ((btn & POWEROFF_BUTTON
#ifdef RC_POWEROFF_BUTTON
|| btn == RC_POWEROFF_BUTTON
#endif
) &&
#if CONFIG_CHARGING && !defined(HAVE_POWEROFF_WHILE_CHARGING)
!charger_inserted() &&
#endif
repeat_count > POWEROFF_COUNT)
{
/* Tell the main thread that it's time to
power off */
sys_poweroff();
/* Safety net for players without hardware
poweroff */
#if (CONFIG_PLATFORM & PLATFORM_NATIVE)
if(repeat_count > POWEROFF_COUNT * 10)
power_off();
#endif
}
#endif
}
}
else
{
if (count++ > REPEAT_START)
{
post = true;
repeat = true;
repeat_count = 0;
/* initial repeat */
count = REPEAT_INTERVAL_START;
}
#ifdef HAVE_TOUCHSCREEN
else if (lastdata != data && btn == lastbtn)
{ /* only coordinates changed, post anyway */
if (touchscreen_get_mode() == TOUCHSCREEN_POINT)
post = true;
}
#endif
}
}
if ( post )
{
if (repeat)
{
/* Only post repeat events if the queue is empty,
* to avoid afterscroll effects. */
if (button_try_post(BUTTON_REPEAT | btn, data))
{
#ifdef HAVE_BACKLIGHT
#ifdef HAVE_REMOTE_LCD
skip_remote_release = false;
#endif
skip_release = false;
#endif
post = false;
}
}
else
{
#ifdef HAVE_BACKLIGHT
#ifdef HAVE_REMOTE_LCD
if (btn & BUTTON_REMOTE) {
if (!remote_filter_first_keypress
|| is_remote_backlight_on(false)
#if defined(IRIVER_H100_SERIES) || defined(IRIVER_H300_SERIES)
|| (remote_type()==REMOTETYPE_H300_NONLCD)
#endif
)
button_try_post(btn, data);
else
skip_remote_release = true;
}
else
#endif
if (!filter_first_keypress || is_backlight_on(false)
#if BUTTON_REMOTE
|| (btn & BUTTON_REMOTE)
#endif
)
button_try_post(btn, data);
else
skip_release = true;
#else /* no backlight, nothing to skip */
button_try_post(btn, data);
#endif
post = false;
}
#ifdef HAVE_REMOTE_LCD
if(btn & BUTTON_REMOTE)
remote_backlight_on();
else
#endif
{
backlight_on();
#ifdef HAVE_BUTTON_LIGHT
buttonlight_on();
#endif
}
reset_poweroff_timer();
}
}
else
{
repeat = false;
count = 0;
}
}
lastbtn = btn & ~(BUTTON_REL | BUTTON_REPEAT);
#ifdef HAVE_BUTTON_DATA
lastdata = data;
#endif
}
void keyboard_irq(int irq, struct pt_regs *regs)
{
int modifiers;
int key;
modifiers = psiongetchar();
key = (modifiers & 0x00FF);
/* no key pressed */
if (key == 0) {
key_repeat = 0;
last_key = 0;
return;
}
if (key == last_key) {
if (key_repeat < 5) {
key_repeat++;
return;
}
}
last_key = key;
key_repeat = 0;
if (modifiers & PSION) {
if (key == 0x31 && power_state == 1) /* Psion + 1 */
power_off();
if (key == 0x20 && power_state == 0) /* Psion + Space */
power_on();
return;
}
if (power_state == 0)
return; /* prevent key presses when off */
if (modifiers & MENU) {
if (key < 0x40 && key > 0x30) { /* MENU + 1..9 */
#ifdef CONFIG_SIBO_VIRTUAL_CONSOLE
Console_set_vc(key - 0x31);
#else
AddQueue(ESC);
AddQueue(key - 0x31 + 'a');
#endif
return;
}
}
switch (key) {
case 0x18: /* Arrow up */
AddQueue(ESC);
AddQueue('A');
return;
case 0x19: /* Arrow down */
AddQueue(ESC);
AddQueue('B');
return;
case 0x1A: /* Arrow right */
AddQueue(ESC);
AddQueue('C');
return;
case 0x1B: /* Arrow left */
AddQueue(ESC);
AddQueue('D');
return;
default:
AddQueue(key);
return;
}
}
DSTATUS disk_initialize(void)
{
u8 n, cmd, ty, ocr[4], rep, timeout;
u16 tmr;
power_on(); /* Force socket power on */
for (n = 10; n; n--) xmit_spi(0xFF); /* Dummy clocks */
ty = 0;
timeout=100;
// Trying to enter Idle state
do {
DESELECT();
xmit_spi(0xFF);
SELECT();
rep = send_cmd(CMD0,0);
} while ((rep != 1) && (--timeout));
if(timeout == 0)
{
DESELECT();
xmit_spi(0xFF);
SELECT();
rep = send_cmd(CMD12,0);
rep = send_cmd(CMD0,0);
if (rep != 1)
{
return STA_NOINIT;
}
}
rep = send_cmd(CMD8, 0x1AA);
// SDHC
if ( rep == 1)
{
for (n = 0; n < 4; n++) ocr[n] = rcvr_spi(); /* Get trailing return value of R7 resp */
if (ocr[2] == 0x01 && ocr[3] == 0xAA) { /* The card can work at vdd range of 2.7-3.6V */
for (tmr = 25000; tmr && send_cmd(ACMD41, 1UL << 30); tmr--) ; /* Wait for leaving idle state (ACMD41 with HCS bit) */
if (tmr && send_cmd(CMD58, 0) == 0) { /* Check CCS bit in the OCR */
for (n = 0; n < 4; n++) ocr[n] = rcvr_spi();
ty = (ocr[0] & 0x40) ? CT_SD2 | CT_BLOCK : CT_SD2; /* SDv2 */
}
}
}
// SDSC or MMC
else
{
if (send_cmd(ACMD41, 0) <= 1) {
ty = CT_SD1; cmd = ACMD41; /* SDv1 */
} else {
ty = CT_MMC; cmd = CMD1; /* MMCv3 */
}
for (tmr = 25000; tmr && send_cmd(cmd, 0); tmr--) ; /* Wait for leaving idle state */
if (!tmr || send_cmd(CMD16, 512) != 0) /* Set R/W block length to 512 */
ty = 0;
}
CardType = ty;
release_spi();
// Initialization succeded
if (ty)
{
FCLK_FAST();
return RES_OK;
}
// Initialization failed
else
{
power_off();
return STA_NOINIT;
}
}
