_mali_osk_errcode_t mali_platform_init(_mali_osk_resource_t *resource) { unsigned long rate; int clk_div; int mali_used = 0; //get mali ahb clock h_ahb_mali = clk_get(NULL, "ahb_mali"); if(!h_ahb_mali){ MALI_PRINT(("try to get ahb mali clock failed!\n")); } //get mali clk h_mali_clk = clk_get(NULL, "mali"); if(!h_mali_clk){ MALI_PRINT(("try to get mali clock failed!\n")); } h_ve_pll = clk_get(NULL, "ve_pll"); if(!h_ve_pll){ MALI_PRINT(("try to get ve pll clock failed!\n")); } //set mali parent clock if(clk_set_parent(h_mali_clk, h_ve_pll)){ MALI_PRINT(("try to set mali clock source failed!\n")); } //set mali clock rate = clk_get_rate(h_ve_pll); if(!script_parser_fetch("mali_para", "mali_used", &mali_used, 1)) { if (mali_used == 1) { if (!script_parser_fetch("mali_para", "mali_clkdiv", &clk_div, 1)) { if (clk_div > 0) { pr_info("mali: use config clk_div %d\n", clk_div); mali_clk_div = clk_div; } } } } pr_info("mali: clk_div %d\n", mali_clk_div); rate /= mali_clk_div; if(clk_set_rate(h_mali_clk, rate)){ MALI_PRINT(("try to set mali clock failed!\n")); } if(clk_enable(h_ahb_mali)){ MALI_PRINT(("try to enable mali ahb failed!\n")); } if(clk_enable(h_mali_clk)){ MALI_PRINT(("try to enable mali clock failed!\n")); } if(clk_reset(h_mali_clk,0)){ MALI_PRINT(("try to reset release failed!\n")); } MALI_PRINT(("mali clock set completed, clock is %d Mhz\n", rate)); MALI_SUCCESS; }
/* Init driver */ static int __init dht22_sun5i_init_driver() { int err = 0; int dht22_used = 0; script_gpio_set_t info; dht22_sun5i_proc = proc_mkdir("dht22", NULL); create_proc_read_entry("raw_data", 0444, dht22_sun5i_proc, dht22_sun5i_proc_read, NULL); err = script_parser_fetch("dht22_para", "dht22_used", &dht22_used, sizeof (dht22_used) / sizeof (int)); if (!dht22_used || err) { printk(KERN_INFO "%s: dht22-bus is not used in config\n", __FUNCTION__); return -EINVAL; } err = script_parser_fetch("dht22_para", "dht22_pin", (int *) &info, sizeof (script_gpio_set_t)); if (err) { printk(KERN_INFO "%s: can not get \"dht22_para\" \"dht22_pin\" gpio handler, already used by others?", __FUNCTION__); return -EBUSY; } dht22_sun5i_gpio_handler = gpio_request_ex("dht22_para", "dht22_pin"); dht22_sun5i_gpio_direction = PIN_DIR_OUT; PIN_DIR(PIN_DIR_OUT); return 0; }
/* ******************************************************************************* * get_usb_cfg * * Description: * void * * Parameters: * void * * Return value: * void * * note: * void * ******************************************************************************* */ static s32 get_usb_cfg(struct sw_hci_hcd *sw_hci) { __s32 ret = 0; /* usbc enable */ ret = script_parser_fetch(usbc_name[sw_hci->usbc_no], "usb_used", (int *)&sw_hci->used, 64); if(ret != 0){ DMSG_PANIC("ERR: get usbc2 enable failed\n"); //return -1; } /* request gpio */ ret = script_parser_fetch(usbc_name[sw_hci->usbc_no], "usb_drv_vbus_gpio", (int *)&sw_hci->drv_vbus_gpio_set, 64); if(ret != 0){ DMSG_PANIC("ERR: get usbc%d(%s) id failed\n", sw_hci->usbc_no, usbc_name[sw_hci->usbc_no]); return -1; } /* host_init_state */ ret = script_parser_fetch(usbc_name[sw_hci->usbc_no], "usb_host_init_state", (int *)&(sw_hci->host_init_state), 64); if(ret != 0){ DMSG_PANIC("ERR: script_parser_fetch host_init_state failed\n"); return -1; } return 0; }
static int ap6210_gpio_wifi_get_res(void) { struct ap6210_gpio_wifi_ops *ops = &ap6210_wifi_select_pm_ops; if (SCRIPT_PARSER_OK != script_parser_fetch(wifi_para, "wifi_used", &ops->wifi_used, 1)) { AP6210_ERR("parse wifi_used failed in script.fex.\n" ); return -1; } if (!ops->wifi_used) { AP6210_ERR("wifi pm disable in script.fex.\n" ); return -1; } if (SCRIPT_PARSER_OK != script_parser_fetch(wifi_para, "wifi_sdc_id", &ops->sdio_id, 1)) { AP6210_ERR("parse wifi_sdc_id in script.fex failed.\n" ); return -1; } if (SCRIPT_PARSER_OK != script_parser_fetch(wifi_para, "wifi_usbc_id", &ops->usb_id, 1)) { AP6210_ERR("parse wifi_sdc_id in script.fex failed.\n" ); return -1; } if (SCRIPT_PARSER_OK != script_parser_fetch(wifi_para, "wifi_mod_sel", &ops->module_sel, 1)) { AP6210_ERR("parse wifi_sdc_id in script.fex failed.\n" ); return -1; } ops->mod_name = ap6210_gpio_wifi_get_name(ops->module_sel); AP6210_ERR("select wifi %s\n", ops->mod_name); return 0; }
void sunxi_pwm_get_sys_config(int pwm) { int ret, val; char primary_key[25]; user_gpio_set_t gpio_info[1]; sprintf(primary_key, "pwm%d_para", pwm); ret = script_parser_fetch(primary_key, "pwm_used", &val, 1); if(ret < 0) { pwm_debug("fetch script data fail\n"); } else { if(val == 1) { ret = script_parser_fetch(primary_key, "pwm_positive", (int *)&gpio_info, sizeof(user_gpio_set_t) / sizeof(int)); if(ret < 0) { pwm_debug("fetch script data fail\n"); } else { pwm_pin_count[pwm]++; memcpy(&pwm_gpio_info[pwm][0], gpio_info, sizeof(user_gpio_set_t)); } ret = script_parser_fetch(primary_key, "pwm_negative", (int *)&gpio_info, sizeof(user_gpio_set_t) / sizeof(int)); if(ret < 0) { pwm_debug("fetch script data fail\n"); } else { pwm_pin_count[pwm]++; memcpy(&pwm_gpio_info[pwm][1], gpio_info, sizeof(user_gpio_set_t)); } } } }
int modify_system_uart(void) { script_gpio_set_t fetch_cfg_gpio[2]; int uart_port_id = 0; char uartname[16] ; char uart_data[8] ; int sdc0_used = 0; if(script_parser_fetch("force_uart_para","force_uart_rx",(int *)(&fetch_cfg_gpio[0]),sizeof(script_gpio_set_t)/4)) { printf("debug_mode_error: can't find force_uart_rx \n"); return -1; } if(script_parser_fetch("force_uart_para","force_uart_tx",(int *)(&fetch_cfg_gpio[1]),sizeof(script_gpio_set_t)/4)) { printf("debug_mode_error: can't find force_uart_tx \n"); return -1; } if(script_parser_fetch("force_uart_para","force_uart_port",(int *)(&uart_port_id),sizeof(int)/4)) { printf("debug_mode_error: can't find card0_tx \n"); return -1; } memset(uartname,0,16); memset(uart_data,0,8); #if defined (CONFIG_ARCH_SUN7I) ||defined(CONFIG_ARCH_SUN8IW1P1) strcat(uartname,"uart_para"); #else strcat(uartname,"uart"); #endif sprintf(uart_data,"%d",uart_port_id); strcat(uartname,uart_data); printf("the uartname is %s \n",uartname); if(script_parser_patch(uartname,"uart_port",(int *)(&uart_port_id),sizeof(int)/4)) { printf("debug_mode_error : can't find uart_debug_port \n"); return -1; } if(script_parser_patch(uartname,"uart_rx",(void*)&fetch_cfg_gpio[0],sizeof(script_gpio_set_t)/4)) { printf("debug_mode_error : can't patch uart_debug_rx\n"); return -1; } if(script_parser_patch(uartname,"uart_tx",(void*)&fetch_cfg_gpio[1],sizeof(script_gpio_set_t)/4)) { printf("debug_mode_error : can't patch uart_debug_rx\n"); return -1; } //disable card0 init in linux if(script_parser_patch("mmc0_para","sdc_used",(int *)(&sdc0_used),sizeof(int)/4)) { printf("debug_mode_error :can not patch sdc_used \n"); return -1; } return 0; }
int check_physical_key_early(void) { user_gpio_set_t gpio_recovery; __u32 gpio_hd; int ret; int gpio_value = 0; int used = 0; int mode = 0; if(uboot_spare_head.boot_data.work_mode != WORK_MODE_BOOT) { return 0; } ret = script_parser_fetch("recovery_para", "used", (int *)&used, sizeof(int) / 4); if (ret || !used) { printf("[recovery] no use\n"); return 0; } ret = script_parser_fetch("recovery_para", "recovery_key", (int *)&gpio_recovery, sizeof(user_gpio_set_t) / 4); if (!ret) { gpio_recovery.mul_sel = 0; //强制设置成输入 gpio_hd = gpio_request(&gpio_recovery, 1); if (gpio_hd) { int time; gpio_value = 0; for(time = 0; time < 4; time++) { gpio_value += gpio_read_one_pin_value(gpio_hd, 0); __msdelay(5); } if (!gpio_value) { printf("[box recovery] find the key\n"); script_parser_fetch("recovery_para", "mode", (int *)&mode, sizeof(int) / 4); if (mode == ONEKEY_USB_RECOVERY_MODE) { gd->key_pressd_value = USB_RECOVERY_KEY_VALUE; } else if (mode == ONEKEY_SPRITE_RECOVERY_MODE) { gd->key_pressd_value = SPRITE_RECOVERY_KEY_VALUE; uboot_spare_head.boot_data.work_mode = WORK_MODE_SPRITE_RECOVERY; } else { printf("[recovery] no option for one key recovery's mode (%d)\n", mode); } } } } return 0; }
int check_boot_recovery_key(void) { user_gpio_set_t gpio_recovery; __u32 gpio_hd; int ret; int gpio_value = 0; int used = 0; int mode = 0; if(uboot_spare_head.boot_data.work_mode != WORK_MODE_BOOT) { return 0; } ret = script_parser_fetch("recovery_para", "used", (int *)&used, sizeof(int) / 4); if (ret || !used) { printf("[recovery] no use\n"); return 0; } ret = script_parser_fetch("recovery_para", "recovery_key", (int *)&gpio_recovery, sizeof(user_gpio_set_t) / 4); if (!ret) { gpio_recovery.mul_sel = 0; //强制设置成输入 gpio_hd = gpio_request(&gpio_recovery, 1); if (gpio_hd) { int time; gpio_value = 0; for(time = 0; time < 4; time++) { gpio_value += gpio_read_one_pin_value(gpio_hd, 0); __msdelay(5); } if (!gpio_value) { script_parser_fetch("recovery_para", "mode", (int *)&mode, sizeof(int) / 4); if (mode == ONEKEY_USB_RECOVERY) { printf("set to one key usb recovery\n"); write_usb_recovery_to_misc(); } else if (mode == ONEKEY_SPRITE_RECOVERY) { printf("set to one key sprite recovery\n"); setenv("bootcmd", "sprite_recovery"); } else { printf("[recovery] no option for one key recovery's mode\n"); } } } } return 0; }
/** * tkey_fetch_sysconfig_para - get config info from sysconfig.fex file. * return value: * = 0; success; * < 0; err */ static int tkey_fetch_sysconfig_para(void) { int ret = -1; int device_used = -1; __u32 twi_addr = 0; char name[I2C_NAME_SIZE]; script_parser_value_type_t type = SCIRPT_PARSER_VALUE_TYPE_STRING; //__u32 twi_id = 0; printk("========HV Inital ===================\n"); if(SCRIPT_PARSER_OK != script_parser_fetch("tkey_para", "tkey_used", &device_used, 1)){ pr_err("hv_keyboard: script_parser_fetch err. \n"); goto script_parser_fetch_err; } if(1 == device_used){ if(SCRIPT_PARSER_OK != script_parser_fetch_ex("tkey_para", "tkey_name", (int *)(&name), &type, sizeof(name)/sizeof(int))){ pr_err("%s: script_parser_fetch err. \n", __func__); goto script_parser_fetch_err; } if(strcmp(HV_NAME, name)){ pr_err("%s: name %s does not match HV_NAME. \n", __func__, name); pr_err(HV_NAME); //ret = 1; return ret; } if(SCRIPT_PARSER_OK != script_parser_fetch("tkey_para", "tkey_twi_addr", &twi_addr, sizeof(twi_addr)/sizeof(__u32))){ pr_err("%s: script_parser_fetch err. \n", name); goto script_parser_fetch_err; } u_i2c_addr.dirty_addr_buf[0] = twi_addr; u_i2c_addr.dirty_addr_buf[1] = I2C_CLIENT_END; printk("%s: after: tkey_twi_addr is 0x%x, dirty_addr_buf: 0x%hx. dirty_addr_buf[1]: 0x%hx \n", \ __func__, twi_addr, u_i2c_addr.dirty_addr_buf[0], u_i2c_addr.dirty_addr_buf[1]); if(SCRIPT_PARSER_OK != script_parser_fetch("tkey_para", "tkey_twi_id", &twi_id, 1)){ pr_err("%s: script_parser_fetch err. \n", name); goto script_parser_fetch_err; } printk("%s: tkey_twi_id is %d. \n", __func__, twi_id); }else{ pr_err("%s: tkey_unused. \n", __func__); ret = -1; } return 0; script_parser_fetch_err: pr_notice("=========script_parser_fetch_err============\n"); return ret; }
/** * gsensor_fetch_sysconfig_para - get config info from sysconfig.fex file. * return value: * = 0; success; * < 0; err */ static int gsensor_fetch_sysconfig_para(void) { int ret = -1; int device_used = -1; __u32 twi_addr = 0; char name[I2C_NAME_SIZE]; script_parser_value_type_t type = SCRIPT_PARSER_VALUE_TYPE_STRING; printk("========%s===================\n", __func__); if(SCRIPT_PARSER_OK != (ret = script_parser_fetch("gsensor_para", "gsensor_used", &device_used, 1))){ pr_err("%s: script_parser_fetch err.ret = %d. \n", __func__, ret); goto script_parser_fetch_err; } if(1 == device_used){ if(SCRIPT_PARSER_OK != script_parser_fetch_ex("gsensor_para", "gsensor_name", (int *)(&name), &type, sizeof(name)/sizeof(int))){ pr_err("%s: line: %d script_parser_fetch err. \n", __func__, __LINE__); goto script_parser_fetch_err; } if(strcmp(SENSOR_NAME, name)){ pr_err("%s: name %s does not match SENSOR_NAME. \n", __func__, name); pr_err(SENSOR_NAME); //ret = 1; return ret; } if(SCRIPT_PARSER_OK != script_parser_fetch("gsensor_para", "gsensor_twi_addr", &twi_addr, sizeof(twi_addr)/sizeof(__u32))){ pr_err("%s: line: %d: script_parser_fetch err. \n", name, __LINE__); goto script_parser_fetch_err; } u_i2c_addr.dirty_addr_buf[0] = twi_addr; u_i2c_addr.dirty_addr_buf[1] = I2C_CLIENT_END; printk("%s: after: gsensor_twi_addr is 0x%x, dirty_addr_buf: 0x%hx. dirty_addr_buf[1]: 0x%hx \n", \ __func__, twi_addr, u_i2c_addr.dirty_addr_buf[0], u_i2c_addr.dirty_addr_buf[1]); if(SCRIPT_PARSER_OK != script_parser_fetch("gsensor_para", "gsensor_twi_id", &twi_id, 1)){ pr_err("%s: script_parser_fetch err. \n", name); goto script_parser_fetch_err; } printk("%s: twi_id is %d. \n", __func__, twi_id); ret = 0; }else{ pr_err("%s: gsensor_unused. \n", __func__); ret = -1; } return ret; script_parser_fetch_err: pr_notice("=========script_parser_fetch_err============\n"); return ret; }
/* ************************************************************************************************************ * * function * * name : * * parmeters : * * return : * * note : * * ************************************************************************************************************ */ static int detect_other_boot_mode(void) { int ret1, ret2; int key_high, key_low; int keyvalue; int user_mode_used = 0; keyvalue = gd->key_pressd_value; printf("key %d\n", keyvalue); script_parser_fetch("platform", "user_mode_used", &user_mode_used, 1); if(user_mode_used) { if(keyvalue >0) { return USER_SELECT_MODE; } } else { ret1 = script_parser_fetch("recovery_key", "key_max", &key_high, 1); ret2 = script_parser_fetch("recovery_key", "key_min", &key_low, 1); if((ret1) || (ret2)) { printf("cant find rcvy value\n"); } else { printf("recovery key high %d, low %d\n", key_high, key_low); if((keyvalue >= key_low) && (keyvalue <= key_high)) { printf("key found, android recovery\n"); return ANDROID_RECOVERY_MODE; } } ret1 = script_parser_fetch("fastboot_key", "key_max", &key_high, 1); ret2 = script_parser_fetch("fastboot_key", "key_min", &key_low, 1); if((ret1) || (ret2)) { printf("cant find fstbt value\n"); } else { printf("fastboot key high %d, low %d\n", key_high, key_low); if((keyvalue >= key_low) && (keyvalue <= key_high)) { printf("key found, android fastboot\n"); return ANDROID_FASTBOOT_MODE; } } } return ANDROID_NULL_MODE; }
static int __init sun4i_vibrator_init(void) { int vibe_used; int err = -1; pr_info("hello, sun4i_vibrator init\n"); err = script_parser_fetch("motor_para", "motor_used", &vibe_used, sizeof(vibe_used)/sizeof(int)); if(err) { pr_err("%s script_parser_fetch \"motor_para\" \"motor_used\" error = %d\n", __FUNCTION__, err); goto exit; } if(!vibe_used) { pr_err("%s motor is not used in config\n", __FUNCTION__); err = -1; goto exit; } err = script_parser_fetch("motor_para", "motor_shake", (int *)&vibe_gpio, sizeof(vibe_gpio)/sizeof(int)); if(err) { pr_err("%s script_parser_fetch \"motor_para\" \"motor_shaked\" error = %d\n", __FUNCTION__, err); goto exit; } vibe_off = vibe_gpio.data; pr_debug("vibe_off is %d\n", vibe_off); vibe_gpio_handler = gpio_request_ex("motor_para", "motor_shake"); if(!vibe_gpio_handler) { pr_err("%s request motor gpio err\n", __FUNCTION__); err = -1; goto exit; } INIT_WORK(&vibrator_work, update_vibrator); spin_lock_init(&vibe_lock); vibe_state = 0; hrtimer_init(&vibe_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); vibe_timer.function = vibrator_timer_func; timed_output_dev_register(&sun4i_vibrator); exit: return err; }
/* ************************************************************************************************************ * * function * * 函数名称:power_oz_patch_gpio * * 参数列表: * * 返回值 : * * 说明 :change the gpio data status in sys_config.fex with the vol input * * ************************************************************************************************************ */ static int power_oz_patch_gpio(int set_vol) { int ret; int i; u8 index; char sub_name[16]; user_gpio_set_t oz_gpio_cfg[3]; memset(oz_gpio_cfg, 0, sizeof(oz_gpio_cfg)); ret = script_parser_fetch("external_power", "a15_vset1", (int*)&oz_gpio_cfg[0], sizeof(oz_gpio_cfg[0])/sizeof(int)); if(ret) { printf("get oz power cfg failed\n"); return -1; } ret = script_parser_fetch("external_power", "a15_vset2", (int*)&oz_gpio_cfg[1], sizeof(oz_gpio_cfg[1])/sizeof(int)); if(ret) { printf("get oz power cfg failed\n"); return -1; } ret = script_parser_fetch("external_power", "a15_vset3", (int*)&oz_gpio_cfg[2], sizeof(oz_gpio_cfg[2])/sizeof(int)); if(ret) { printf("get oz power cfg failed\n"); return -1; } //get the gpio status with the set_vol index = power_oz_probe_gpio(set_vol); //配置gpio data for(i = 0; i < 3; i++) { oz_gpio_cfg[i].data = gpio_value[index][i]; memset(sub_name, 0, 16); sprintf(sub_name, "%s%d", "a15_vset", i+1); ret = script_parser_patch("external_power", sub_name, (void *)&oz_gpio_cfg[i], sizeof(oz_gpio_cfg[i])/sizeof(int)); if(ret) { printf("patch gpio config failed\n"); return -2; } } return 0; }
__s32 Hdmi_init(void) { s32 ret = 0; disp_hdmi_func disp_func; s32 val; hdmi_used = 0; ret = script_parser_fetch("hdmi_para", "hdmi_used", &val, 1); if(ret == 0) { hdmi_used = val; if(hdmi_used) { #if defined(CONFIG_ARCH_HOMELET) //need to be same later ret = script_parser_fetch("hdmi_para", "hdmi_power_boot", (int *)hdmi_power, 25); #else ret = script_parser_fetch("hdmi_para", "hdmi_power", (int *)hdmi_power, 25); #endif if(ret == 0) { OSAL_Power_Enable(hdmi_power); } ret = script_parser_fetch("hdmi_para", "hdmi_cts_compatibility", &val, 1); if(ret == 0) { Hdmi_hal_cts_enable(val); printf("cts_enable, %d\n", val); } ret = script_parser_fetch("hdmi_para", "hdmi_hdcp_enable", &val, 1); if(ret == 0) { Hdmi_hal_hdcp_enable(val); printf("hdcp_enable, %d\n", val); } Hdmi_hal_init(); disp_func.hdmi_open = Hdmi_open; disp_func.hdmi_close = Hdmi_close; disp_func.hdmi_set_mode = Hdmi_set_display_mode; disp_func.hdmi_mode_support = Hdmi_mode_support; disp_func.hdmi_get_HPD_status = Hdmi_get_HPD_status; disp_func.hdmi_get_video_timing_info = Hdmi_get_video_timming_info; disp_func.hdmi_get_video_info_index = Hdmi_get_video_info_index; disp_set_hdmi_func(0, &disp_func); disp_set_hdmi_func(1, &disp_func); } } return 0; }
static int __init sw_serial_init(void) { int ret; int i; int used = 0; char uart_para[16]; memset(sw_serial, 0, sizeof(sw_serial)); uart_used = 0; for (i=0; i<MAX_PORTS; i++, used=0) { sprintf(uart_para, "uart_para%d", i); ret = script_parser_fetch(uart_para, "uart_used", &used, sizeof(int)); if (ret) UART_MSG("failed to get uart%d's used information\n", i); if (used) { uart_used |= 1 << i; platform_device_register(&sw_uart_dev[i]); } } if (uart_used) { UART_MSG("used uart info.: 0x%02x\n", uart_used); ret = platform_driver_register(&sw_serial_driver); return ret; } return 0; }
int OSAL_Script_FetchParser_Data(char *main_name, char *sub_name, int value[], int count) { int ret; user_gpio_set_t gpio_info; disp_gpio_set_t *gpio_list; ret = script_parser_fetch(main_name, sub_name, value, count); if(ret < 0) { //__wrn("fetch script data %s.%s fail\n", main_name, sub_name); } else { if(count == 1) { //__inf("%s.%s = %d\n", main_name, sub_name, *value); } else if(count == sizeof(disp_gpio_set_t)) { memcpy(&gpio_info, value, sizeof(user_gpio_set_t)); gpio_list = (disp_gpio_set_t *)value; gpio_list->port = gpio_info.port; gpio_list->port_num = gpio_info.port_num; gpio_list->drv_level = gpio_info.drv_level; gpio_list->pull = gpio_info.pull; gpio_list->data = gpio_info.data; //__inf("%s.%s gpio_port=%d,gpio_port_num:%d, data:%d\n",main_name, sub_name, gpio_list->port, gpio_list->port_num, gpio_list->data); } else { //__inf("%s.%s = %s\n", main_name, sub_name, value); } } return ret; }
static int __init sndspdif_codec_init(void) { int ret, spdif_used = 0; ret = script_parser_fetch("spdif_para", "spdif_used", &spdif_used, 1); if (ret != 0 || !spdif_used) return -ENODEV; spd_gpio_hdle = gpio_request_ex("spdif_para", "spdif_dout"); if (0 == spd_gpio_hdle) { pr_err("try to request spdif_para gpio failed\n"); return -1; } ret = platform_device_register(&sndspdif_codec_device); if (ret < 0) return ret; ret = platform_driver_register(&sndspdif_codec_driver); if (ret < 0) { platform_device_unregister(&sndspdif_codec_device); return ret; } return 0; }
/* ************************************************************************************************************ * * function * * 函数名称: * * 参数列表: * * 返回值 : * * 说明 : * * ************************************************************************************************************ */ int power_oz_probe(void) { int ret; u32 oz_power_hd; user_gpio_set_t oz_gpio_cfg[1]; memset(oz_gpio_cfg, 0, sizeof(oz_gpio_cfg)); ret = script_parser_fetch("external_power", "a15_pwr_en", (int*)&oz_gpio_cfg[0], sizeof(oz_gpio_cfg[0])/sizeof(int)); if(ret) { printf("get a15_pwr_en cfg failed\n"); return -1; } oz_gpio_cfg[0].data = 1; //配置使能gpio ret = script_parser_patch("external_power", "a15_pwr_en", (int*)&oz_gpio_cfg[0], sizeof(oz_gpio_cfg[0])/sizeof(int)); if(ret) { printf("patch a15_pwr_en config failed\n"); return -2; } oz_power_hd = gpio_request_simple("external_power", "a15_pwr_en"); if(oz_power_hd) { printf("set gpio failed\n"); return -3; } return 0; }
static int board_probe_bat_status(int standby_mode) { int bat_cal = 1; int ret, chargemode = 0; //当前可以确定是火牛开机,但是是否开机还不确定,需要确认电池是否存在 //当电池不存在即开机,电池存在则关机 //新添加,根据环境变量,是启动当前的待机,或者android待机功能 ret = script_parser_fetch("charging_type", "charging_type", &chargemode, 1); if((!ret) && chargemode) { gd->chargemode = 1; return 0; } if(battery_charge_cartoon_init(0) < 0) { tick_printf("init charge cartoon fail\n"); return -1; } bat_cal = axp_probe_rest_battery_capacity(); printf("bat not inited\n"); if(battery_charge_cartoon_init(bat_cal/(100/(SUNXI_BAT_BMP_MAX-1))) < 0) { tick_printf("init charge cartoon fail\n"); return -1; } if((!bat_cal) && (standby_mode)) { bat_cal = 100; } return bat_cal; }
static void __exit gpio_sw_exit(void) { int i, gpio_key_count,gpio_used,ret; ret = script_parser_fetch("gpio_para", "gpio_used", &gpio_used, sizeof(int)); if (ret){ GPIO_SW_DEBUG("failed to get gpio's used information\n"); goto EXIT_END; } if(!gpio_used){ GPIO_SW_DEBUG("gpio module is used not \n"); goto EXIT_END; } gpio_key_count = script_parser_mainkey_get_gpio_count("gpio_para"); if(all_irq_enable){ __raw_writel(0x00, GPIO_TEST_BASE + 0x210); free_irq(GPIO_IRQ,NULL); } for(i=0;i<gpio_key_count;i++){ GPIO_SW_DEBUG("gpio_sw_dev[%d] addr = %x \n",i,&gpio_sw_dev[i]); gpio_key_count = script_parser_mainkey_get_gpio_count("gpio_para"); platform_device_unregister(&gpio_sw_dev[i]); } GPIO_SW_DEBUG("platform_device_unregister finish ! \n"); GPIO_SW_DEBUG("gpio_sw_driver addr = %x \n",&gpio_sw_driver); platform_driver_unregister(&gpio_sw_driver); EXIT_END: GPIO_SW_DEBUG("gpio_exit finish ! \n"); }
static int __init sun5i_sndi2s_init(void) { int ret; int ret2; ret2 = script_parser_fetch("i2s_para","i2s_used", &i2s_used, sizeof(int)); if (ret2) { printk("[I2S]sun5i_sndi2s_init fetch i2s using configuration failed\n"); } if (i2s_used) { sun5i_sndi2s_device = platform_device_alloc("soc-audio", 2); if(!sun5i_sndi2s_device) return -ENOMEM; platform_set_drvdata(sun5i_sndi2s_device, &snd_soc_sun5i_sndi2s); ret = platform_device_add(sun5i_sndi2s_device); if (ret) { platform_device_put(sun5i_sndi2s_device); } }else{ printk("[I2S]sun5i_sndi2s cannot find any using configuration for controllers, return directly!\n"); return 0; } return ret; }
static int __init sun5i_spdif_init(void) { int err = 0; int ret; ret = script_parser_fetch("spdif_para","spdif_used", &spdif_used, sizeof(int)); if (ret) { printk("[SPDIF]sun5i_spdif_init fetch spdif using configuration failed\n"); } if (spdif_used) { spdif_handle = gpio_request_ex("spdif_para", NULL); if((platform_device_register(&sun5i_spdif_device))<0) return err; if ((err = platform_driver_register(&sun5i_spdif_driver)) < 0) return err; } else { printk("[SPDIF]sun5i-spdif cannot find any using configuration for controllers, return directly!\n"); return 0; } return 0; }
static void check_debug_mode(void) { //if enter debug mode,set loglevel = 8 char change_env_data[32]; char *env_concole = "ttyS"; int baud = 115200; int port_id = 0; if(!loglel_change_flag) return ; memset(change_env_data,0,32); sprintf(change_env_data, "%d",8); setenv("loglevel",change_env_data); if(script_parser_fetch("force_uart_para","force_uart_port",&port_id,sizeof(int)/4)) { printf("card0_print_para port_id fetch error\n"); return ; } memset(change_env_data,0,32); strcat(change_env_data,"ttyS"); sprintf(change_env_data,"%s%d%s%d",env_concole,port_id,",",baud); setenv("console",change_env_data); return ; }
/* Init driver module */ INT __init rtusb_init(void) { int ret = 0; printk("rtusb init %s --->\n", RTMP_DRV_NAME); ret = script_parser_fetch("usb_wifi_para", "usb_wifi_usbc_num", (int *)&usb_wifi_host, 64); if(ret != 0){ printk("ERR: script_parser_fetch usb_wifi_usbc_num failed\n"); ret = -ENOMEM; return ret; } printk("sw_usb_enable_hcd: usbc_num = %d\n", usb_wifi_host); sw_usb_enable_hcd(usb_wifi_host); #ifdef RESOURCE_BOOT_ALLOC { int status; status = rtusb_resource_init(rtusb_tx_buf_len, rtusb_rx_buf_len, rtusb_tx_buf_cnt, rtusb_rx_buf_cnt); if (status) { printk("resource allocate failed, don't register driver!\n"); return -1; } } #endif /* RESOURCE_BOOT_ALLOC */ return usb_register(&rtusb_driver); }
/* ************************************************************************************************************ * * function * * name : 一键恢复的按键检测 * * parmeters : * * return : * * note : [email protected] * * ************************************************************************************************************ */ int check_boot_recovery_key(void) { user_gpio_set_t gpio_recovery; __u32 gpio_hd; int gpio_value = 0; int ret; ret = script_parser_fetch("system", "recovery_key", (int *)&gpio_recovery, sizeof(user_gpio_set_t)/4); if (!ret) { gpio_recovery.mul_sel = 0; //强制设置成输入 gpio_hd = gpio_request(&gpio_recovery, 1); if (gpio_hd) { int k; gpio_value = 0; for(k=0;k<4;k++) { gpio_value += gpio_read_one_pin_value(gpio_hd, 0); __msdelay(5); } if (!gpio_value) { printf("set to recovery\n"); return 0; } } } return 1; }
/* ************************************************************************************************************ * * function * * name : * * parmeters : * * return : * * note : * * ************************************************************************************************************ */ int sunxi_set_secure_mode(void) { int mode; int ret; int secure_bit = 0; if(gd->securemode == SUNXI_NORMAL_MODE) { if(!script_parser_fetch("platform","secure_bit",&secure_bit,1)) { mode = sid_probe_security_mode(); if((mode == 0)&&(secure_bit == 1)) { ret = axp_set_supply_status(0, PMU_SUPPLY_ELDO2, 1800, 1); if(ret) { printf("set eldo2 to 1800 failed\n"); return -1; } else { sid_set_security_mode(); } } } } return 0; }
/* ************************************************************************************************************ * * function * * name : * * parmeters : * * return : * * note : * * ************************************************************************************************************ */ void dram_init_banksize(void) { /* * We should init the Dram options, and kernel get it by tag. */ int dram_size; int ret; //gd->ram_size = get_ram_size((long *)PHYS_SDRAM_1, PHYS_SDRAM_1_SIZE); ret = script_parser_fetch("dram_para", "dram_para1", &dram_size, 1); if(!ret) { dram_size &= 0xffff; if(dram_size) { gd->bd->bi_dram[0].size = dram_size * 1024 * 1024; } else { gd->bd->bi_dram[0].size = get_ram_size((long *)PHYS_SDRAM_1, PHYS_SDRAM_1_SIZE); } } else { gd->bd->bi_dram[0].size = get_ram_size((long *)PHYS_SDRAM_1, PHYS_SDRAM_1_SIZE); } gd->bd->bi_dram[0].start = PHYS_SDRAM_1; }
/* ************************************************************************************************************ * * function * * 函数名称: * * 参数列表: * * 返回值 : * * 说明 : * * ************************************************************************************************************ */ static int axp20_set_dcdc3(int set_vol, int onoff) { s32 vol_value; s32 ret; u8 reg_addr; u8 reg_value; if(set_vol == -1) { if(!dcdc3_user_set) { ret = script_parser_fetch("target", "dcdc3_vol", &vol_value, 1); if(ret) { printf("boot power:unable to find dcdc3 set\n"); return -1; } dcdc3_user_set = vol_value; } vol_value = dcdc3_user_set; } else { vol_value = set_vol; } if(!vol_value) { reg_addr = BOOT_POWER20_OUTPUT_CTL; if(!axp_i2c_read(AXP20_ADDR, reg_addr, ®_value)) { reg_value &= ~(1<<1); if(axp_i2c_write(AXP20_ADDR, reg_addr, reg_value)) { printf("boot power:unable to close dcdc3\n"); return -1; } } } else { reg_addr = BOOT_POWER20_DC3OUT_VOL; if(!axp_i2c_read(AXP20_ADDR, reg_addr, ®_value)) { if((vol_value >= 700) && (vol_value <= 3500)) { reg_value &= 0x80; reg_value = ((vol_value - 700)/25); if(axp_i2c_write(AXP20_ADDR, reg_addr, reg_value)) { printf("boot power:unable to set dcdc3\n"); return -1; } } } } return 0; }
static int sw_serial_get_config(struct sw_serial_port *sport, u32 uart_id) { char uart_para[16] = {0}; int ret; sprintf(uart_para, "uart_para%d", uart_id); ret = script_parser_fetch(uart_para, "uart_port", &sport->port_no, sizeof(int)); if (ret) return -1; if (sport->port_no != uart_id) return -1; ret = script_parser_fetch(uart_para, "uart_type", &sport->pin_num, sizeof(int)); if (ret) return -1; return 0; }
/* ************************************************************************************************************ * * function * * 函数名称: * * 参数列表: * * 返回值 : * * 说明 : * * ************************************************************************************************************ */ static int axp20_set_ldo2(int set_vol, int onoff) { s32 vol_value; s32 ret; u8 reg_addr; u8 reg_value; if(set_vol == -1) { if(!ldo2_user_set) { ret = script_parser_fetch("target", "ldo2_vol", &vol_value, 1); if(ret) { printf("boot power:unable to find ldo2 set\n"); return -1; } ldo2_user_set = vol_value; } vol_value = ldo2_user_set; } else { vol_value = set_vol; } if(!vol_value) { reg_addr = BOOT_POWER20_OUTPUT_CTL; if(!axp_i2c_read(AXP20_ADDR, reg_addr, ®_value)) { reg_value &= ~(1<<2); if(axp_i2c_write(AXP20_ADDR, reg_addr, reg_value)) { printf("boot power:unable to set ldo2\n"); return -1; } } } else { reg_addr = BOOT_POWER20_LDO24OUT_VOL; if(!axp_i2c_read(AXP20_ADDR, reg_addr, ®_value)) { if((vol_value >= 1800) && (vol_value <= 3300)) { reg_value &= 0x0f; reg_value |= (((vol_value - 1800)/100) << 4); if(axp_i2c_write(AXP20_ADDR, reg_addr, reg_value)) { printf("boot power:unable to set ldo2\n"); return -1; } } } } return 0; }