static void debug_read_build_id(struct seq_file *s) { unsigned size; void *data; data = smem_get_entry(SMEM_HW_SW_BUILD_ID, &size, 0, SMEM_ANY_HOST_FLAG); if (!data) return; seq_write(s, data, size); }
static void smsm_state_cb_hdlr(void *data, uint32_t old_state, uint32_t new_state) { char *smem_reset_reason; char buffer[MAX_BUF_SIZE]; unsigned smem_reset_size; unsigned size; riva_crash = true; pr_err("%s: smsm state changed\n", MODULE_NAME); if (!(new_state & SMSM_RESET)) return; if (ss_restart_inprogress) { pr_err("%s: Ignoring smsm reset req, restart in progress\n", MODULE_NAME); return; } pr_info(MODULE_NAME ": smsm_state_cb_hdlr, enable_riva_ssr=%d.\n", enable_riva_ssr); //ASUS_BSP+++ "for /data/log/ASUSEvtlog" ASUSEvtlog("[wcnss]: smsm_state_cb_hdlr, enable_riva_ssr=%d.\n", enable_riva_ssr); //ASUS_BSP--- "for /data/log/ASUSEvtlog" if (!enable_riva_ssr) panic(MODULE_NAME ": SMSM reset request received from Riva"); smem_reset_reason = smem_get_entry(SMEM_SSR_REASON_WCNSS0, &smem_reset_size); if (!smem_reset_reason || !smem_reset_size) { pr_err("%s: wcnss subsystem failure reason: %s\n", __func__, "(unknown, smem_get_entry failed)"); } else if (!smem_reset_reason[0]) { pr_err("%s: wcnss subsystem failure reason: %s\n", __func__, "(unknown, init string found)"); } else { size = smem_reset_size < MAX_BUF_SIZE ? smem_reset_size : (MAX_BUF_SIZE - 1); memcpy(buffer, smem_reset_reason, size); buffer[size] = '\0'; pr_err("%s: wcnss subsystem failure reason: %s\n", __func__, buffer); memset(smem_reset_reason, 0, smem_reset_size); wmb(); } ss_restart_inprogress = true; subsystem_restart("riva"); }
static void smsm_state_cb_hdlr(void *data, uint32_t old_state, uint32_t new_state) { char *smem_reset_reason; char buffer[MAX_BUF_SIZE]; unsigned smem_reset_size; unsigned size; riva_crash = true; pr_err("%s: smsm state changed\n", MODULE_NAME); wcnss_riva_dump_pmic_regs(); if (!(new_state & SMSM_RESET)) return; if (ss_restart_inprogress) { pr_err("%s: Ignoring smsm reset req, restart in progress\n", MODULE_NAME); return; } if (!enable_riva_ssr) panic(MODULE_NAME ": SMSM reset request received from Riva"); smem_reset_reason = smem_get_entry(SMEM_SSR_REASON_WCNSS0, &smem_reset_size); if (!smem_reset_reason || !smem_reset_size) { pr_err("%s: wcnss subsystem failure reason: %s\n", __func__, "(unknown, smem_get_entry failed)"); } else if (!smem_reset_reason[0]) { pr_err("%s: wcnss subsystem failure reason: %s\n", __func__, "(unknown, init string found)"); } else { size = smem_reset_size < MAX_BUF_SIZE ? smem_reset_size : (MAX_BUF_SIZE - 1); memcpy(buffer, smem_reset_reason, size); buffer[size] = '\0'; pr_err("%s: wcnss subsystem failure reason: %s\n", __func__, buffer); #ifdef CONFIG_RAMDUMP_TAGS rdtags_add_tag("ssr_reason", buffer, strnlen(buffer, MAX_BUF_SIZE - 1) + 1); #endif memset(smem_reset_reason, 0, smem_reset_size); wmb(); } ss_restart_inprogress = true; subsystem_restart_dev(riva_8960_dev); }
static void smsm_state_cb_hdlr(void *data, uint32_t old_state, uint32_t new_state) { char *smem_reset_reason; char buffer[MAX_BUF_SIZE]; unsigned smem_reset_size; unsigned size; riva_crash = true; pr_err("%s: smsm state changed\n", MODULE_NAME); if (!(new_state & SMSM_RESET)) return; if (ss_restart_inprogress) { pr_err("%s: Ignoring smsm reset req, restart in progress\n", MODULE_NAME); return; } if (!enable_riva_ssr) { #if defined(CONFIG_LGE_HANDLE_PANIC) lge_set_magic_for_subsystem("wcnss"); msm_set_restart_mode(0x6d632130); #endif panic(MODULE_NAME ": SMSM reset request received from Riva"); } smem_reset_reason = smem_get_entry(SMEM_SSR_REASON_WCNSS0, &smem_reset_size); if (!smem_reset_reason || !smem_reset_size) { pr_err("%s: wcnss subsystem failure reason: %s\n", __func__, "(unknown, smem_get_entry failed)"); } else if (!smem_reset_reason[0]) { pr_err("%s: wcnss subsystem failure reason: %s\n", __func__, "(unknown, init string found)"); } else { size = smem_reset_size < MAX_BUF_SIZE ? smem_reset_size : (MAX_BUF_SIZE - 1); memcpy(buffer, smem_reset_reason, size); buffer[size] = '\0'; pr_err("%s: wcnss subsystem failure reason: %s\n", __func__, buffer); memset(smem_reset_reason, 0, smem_reset_size); wmb(); } ss_restart_inprogress = true; subsystem_restart_dev(riva_8960_dev); }
int anx7808_get_sbl_cable_type(void) { int cable_type = 0; unsigned int *p_cable_type = (unsigned int *) (smem_get_entry(SMEM_ID_VENDOR1, &cable_smem_size)); if (p_cable_type) cable_type = *p_cable_type; else cable_type = 0; return cable_type; }
static int __init mdm_modem_probe(struct platform_device *pdev) { unsigned *br; unsigned sz; br = (unsigned *) smem_get_entry(SMEM_POWER_ON_STATUS_INFO, &sz); if (br != NULL && sz != 0) mdm_is_charge_only = *br & BOOT_REASON_CHG_USB || *br & BOOT_REASON_CHG_WALL; else pr_err("%s: Unable to read boot reason.\n", __func__); return mdm_common_create(pdev, &mdm_cb); }
static void msm_pm_restart(char str, const char *cmd) { int rc; unsigned size; #if defined(CONFIG_MACH_ARUBASLIM_OPEN) unsigned int freq = 600000; rc = acpuclk_set_rate(0, freq, SETRATE_CPUFREQ); if (rc) { printk(KERN_ERR "%s(): failed to restore clock rate(%lu)\n", __func__, freq); } pr_info("%s: Current ACPU frequency %ld\n", __func__, acpuclk_get_rate(0)); #endif samsung_vendor1_id *smem_vendor1 = \ (samsung_vendor1_id *)smem_get_entry(SMEM_ID_VENDOR1, &size); if (smem_vendor1) { smem_vendor1->silent_reset = 0xAEAEAEAE; smem_vendor1->reboot_reason = restart_reason; smem_vendor1->AP_reserved[0] = 0; } else { printk(KERN_EMERG "smem_flag is NULL\n"); } pr_debug("The reset reason is %x\n", restart_reason); rc = ncp6335d_restart_config(); if (rc) pr_err("Unable to configure NCP6335D for restart\n"); /* Disable interrupts */ local_irq_disable(); local_fiq_disable(); /* * Take out a flat memory mapping and will * insert a 1:1 mapping in place of * the user-mode pages to ensure predictable results * This function takes care of flushing the caches * and flushing the TLB. */ setup_mm_for_reboot(); msm_proc_comm(PCOM_RESET_CHIP, &restart_reason, 0); for (;;) ; }
static void smsm_state_cb_hdlr(void *data, uint32_t old_state, uint32_t new_state) { char *smem_reset_reason; char buffer[MAX_BUF_SIZE]; unsigned smem_reset_size; unsigned size; riva_crash = true; pr_err("%s: smsm state changed\n", MODULE_NAME); if (!(new_state & SMSM_RESET)) return; if (get_kernel_flag() & KERNEL_FLAG_ENABLE_SSR_WCNSS) smsm_change_state_ssr(SMSM_APPS_STATE, SMSM_RESET, 0, KERNEL_FLAG_ENABLE_SSR_WCNSS); if (ss_restart_inprogress) { pr_err("%s: Ignoring smsm reset req, restart in progress\n", MODULE_NAME); return; } if (!enable_riva_ssr) panic(MODULE_NAME ": SMSM reset request received from Riva"); smem_reset_reason = smem_get_entry(SMEM_SSR_REASON_WCNSS0, &smem_reset_size); if (!smem_reset_reason || !smem_reset_size) { pr_err("%s: wcnss subsystem failure reason: %s\n", __func__, "(unknown, smem_get_entry failed)"); } else if (!smem_reset_reason[0]) { pr_err("%s: wcnss subsystem failure reason: %s\n", __func__, "(unknown, init string found)"); } else { size = smem_reset_size < MAX_BUF_SIZE ? smem_reset_size : (MAX_BUF_SIZE - 1); memcpy(buffer, smem_reset_reason, size); buffer[size] = '\0'; pr_err("%s: wcnss subsystem failure reason: %s\n", __func__, buffer); memset(smem_reset_reason, 0, smem_reset_size); wmb(); } ss_restart_inprogress = true; subsystem_restart("riva"); }
static int debug_read_build_id(char *buf, int max) { unsigned size; void *data; data = smem_get_entry(SMEM_HW_SW_BUILD_ID, &size); if (!data) return 0; if (size >= max) size = max; memcpy(buf, data, size); return size; }
void create_testmode_status(void) { static uint32_t *p_smem_testmode_status ; static int l_testmode_status ; int size ; p_smem_testmode_status = smem_get_entry( SMEM_ID_VENDOR0 ,&size ) ; if( p_smem_testmode_status ) l_testmode_status = *p_smem_testmode_status ; create_proc_read_entry("is_phone_testmode", S_IRUGO, NULL , testmode_read_proc,&l_testmode_status); }
void create_qpst_enable_status(void) { short *p_smem_qpst_enable_status ; static int qpst_enable_status = -1 ; int size ; p_smem_qpst_enable_status = smem_get_entry( SMEM_ID_VENDOR2 ,&size ) ; if( p_smem_qpst_enable_status ) qpst_enable_status = *p_smem_qpst_enable_status ; if(qpst_enable_status!=-1) //QPST_DISABLED = -1, osbl_dload_mproc.c create_proc_read_entry("qpst_enable", S_IRUGO, NULL , qpst_enable_read_proc,&qpst_enable_status); }
static int debug_modem_err_f3(char *buf, int max) { char *x; int size; int i = 0, j = 0; unsigned cols = 0; char str[4*sizeof(unsigned)+1] = {0}; x = smem_get_entry(SMEM_ERR_F3_TRACE_LOG, &size); if (x != 0) { pr_info("smem: F3 TRACE LOG\n"); while (size > 0 && max - i) { if (size >= sizeof(unsigned)) { i += scnprintf(buf + i, max - i, "%08x", *((unsigned *) x)); for (j = 0; j < sizeof(unsigned); ++j) if (isprint(*(x+j))) str[cols*sizeof(unsigned) + j] = *(x+j); else str[cols*sizeof(unsigned) + j] = '-'; x += sizeof(unsigned); size -= sizeof(unsigned); } else { while (size-- > 0 && max - i) i += scnprintf(buf + i, max - i, "%02x", (unsigned) *x++); break; } if (cols == 3) { cols = 0; str[4*sizeof(unsigned)] = 0; i += scnprintf(buf + i, max - i, " %s\n", str); str[0] = 0; } else { cols++; i += scnprintf(buf + i, max - i, " "); } } i += scnprintf(buf + i, max - i, "\n"); } return i; }
void create_smpl_reset_status(void) { static uint32_t *p_smem_pwr_on_status ; static int l_power_on_status ; int size ; p_smem_pwr_on_status = smem_get_entry( SMEM_POWER_ON_STATUS_INFO, &size ) ; if( p_smem_pwr_on_status ) l_power_on_status = *p_smem_pwr_on_status ; l_power_on_status = (l_power_on_status & 0x8) ? 1 : 0; create_proc_read_entry("smpl_reset", S_IRUGO, NULL , smpl_reset_read_proc,&l_power_on_status); }
static void msm_pm_power_off(void) { unsigned size = 0; samsung_vendor1_id *smem_vendor1 = \ (samsung_vendor1_id *)smem_get_entry(SMEM_ID_VENDOR1, &size); if (smem_vendor1) { smem_vendor1->AP_reserved[0] = 0; } else { printk(KERN_EMERG "smem_flag is NULL\n"); } printk("[msm_pm_power_off] START!!! \n"); msm_proc_comm(PCOM_POWER_DOWN, 0, 0); for (;;) ; }
static int __init ram_console_late_init(void) { struct proc_dir_entry *entry; struct persistent_ram_zone *prz = ram_console_zone; /*Skies-2012/09/07, create proc file for crash status++*/ struct proc_dir_entry *entry_cs; int size = 0; /*Skies-2012/09/07, create proc file for crash status--*/ /*Skies-2012/09/07, create proc file for crash status++*/ entry_cs = create_proc_entry("crash_status", S_IFREG|S_IRUGO/*|S_IWUGO*/, NULL); if (!entry_cs) { pr_err("%s: failed to create proc entry\n", __func__); return 0; } entry_cs->proc_fops = &crash_status_file_ops; entry_cs->size = CRASH_STATUS_CMD_SIZE; debug_info_buf = smem_get_entry(SMEM_ID_VENDOR0, &size); if (debug_info_buf != NULL) { memcpy(&debug_info, debug_info_buf, sizeof(debug_info)); }else { return 0; } /*Skies-2012/09/07, create proc file for crash status--*/ if (!prz) return 0; if (persistent_ram_old_size(prz) == 0) return 0; entry = create_proc_entry("last_kmsg", S_IFREG | S_IRUGO, NULL); if (!entry) { printk(KERN_ERR "ram_console: failed to create proc entry\n"); persistent_ram_free_old(prz); return 0; } entry->proc_fops = &ram_console_file_ops; entry->size = persistent_ram_old_size(prz) + persistent_ram_ecc_string(prz, NULL, 0) + bootinfo_size; return 0; }
static void dsps_log_sfr(void) { const char dflt_reason[] = "Died too early due to unknown reason"; char *smem_reset_reason; unsigned smem_reset_size; smem_reset_reason = smem_get_entry(SMEM_SSR_REASON_DSPS0, &smem_reset_size); if (smem_reset_reason != NULL && smem_reset_reason[0] != 0) { smem_reset_reason[smem_reset_size-1] = 0; pr_err("%s: DSPS failure: %s\nResetting DSPS\n", __func__, smem_reset_reason); memset(smem_reset_reason, 0, smem_reset_size); wmb(); } else pr_err("%s: DSPS failure: %s\nResetting DSPS\n", __func__, dflt_reason); }
static void hfi_process_sys_get_prop_image_version( struct hfi_msg_sys_property_info_packet *pkt) { int i = 0; u32 smem_block_size = 0; u8 *smem_table_ptr; char version[256]; const u32 version_string_size = 128; const u32 smem_image_index_venus = 14 * 128; u8 *str_image_version; int req_bytes; req_bytes = pkt->size - sizeof(*pkt); if (req_bytes < version_string_size || !pkt->rg_property_data[1] || pkt->num_properties > 1) { dprintk(VIDC_ERR, "hfi_process_sys_get_prop_image_version:bad_pkt: %d", req_bytes); return; } str_image_version = (u8 *)&pkt->rg_property_data[1]; /* * The version string returned by firmware includes null * characters at the start and in between. Replace the null * characters with space, to print the version info. */ for (i = 0; i < version_string_size; i++) { if (str_image_version[i] != '\0') version[i] = str_image_version[i]; else version[i] = ' '; } version[i] = '\0'; dprintk(VIDC_DBG, "F/W version: %s\n", version); smem_table_ptr = smem_get_entry(SMEM_IMAGE_VERSION_TABLE, &smem_block_size); if (smem_table_ptr && ((smem_image_index_venus + version_string_size) <= smem_block_size)) memcpy(smem_table_ptr + smem_image_index_venus, str_image_version, version_string_size); }
static void smsm_state_cb_hdlr(void *data, uint32_t old_state, uint32_t new_state) { struct riva_data *drv = data; char *smem_reset_reason; char buffer[81]; unsigned smem_reset_size; unsigned size; drv->crash = true; if (!(new_state & SMSM_RESET)) return; if (drv->rst_in_progress) { pr_err("riva: Ignoring smsm reset req, restart in progress\n"); return; } pr_err("riva: smsm state changed to smsm reset\n"); wcnss_riva_dump_pmic_regs(); smem_reset_reason = smem_get_entry(SMEM_SSR_REASON_WCNSS0, &smem_reset_size); if (!smem_reset_reason || !smem_reset_size) { pr_err("wcnss subsystem failure reason:\n" "(unknown, smem_get_entry failed)"); } else if (!smem_reset_reason[0]) { pr_err("wcnss subsystem failure reason:\n" "(unknown, init string found)"); } else { size = smem_reset_size < sizeof(buffer) ? smem_reset_size : (sizeof(buffer) - 1); memcpy(buffer, smem_reset_reason, size); buffer[size] = '\0'; pr_err("wcnss subsystem failure reason: %s\n", buffer); memset(smem_reset_reason, 0, smem_reset_size); wmb(); } drv->rst_in_progress = 1; subsystem_restart_dev(drv->subsys); }
static void modem_restart_amsslog_backup(void) { struct ramdump_log *buffer = amsslog_backup_addr; char *smem_errlog = NULL; size_t size; smem_errlog = smem_get_entry(SMEM_ERR_CRASH_LOG, &size); printk(KERN_INFO "amsslog: crash log size=%d\n", size); if (smem_errlog && !memcmp(smem_errlog, "ERR", 3)) { buffer->sig = AMSSLOG_SIG; buffer->size = amsslog_backup_size - 2 * sizeof(unsigned int); if (buffer->size > size) buffer->size = size; memcpy(buffer->data, smem_errlog, buffer->size); } }
static int remote_spinlock_dal_init(const char *chunk_name, _remote_spinlock_t *lock) { void *dal_smem_start, *dal_smem_end; uint32_t dal_smem_size; struct dal_chunk_header *cur_header; if (!chunk_name) return -EINVAL; #if defined(CONFIG_QCT_LTE) dal_smem_start = smem_get_entry(SMEM_DAL_AREA, &dal_smem_size); #else dal_smem_start = smem_item(SMEM_DAL_AREA, &dal_smem_size); #endif if (!dal_smem_start) return -ENXIO; dal_smem_end = dal_smem_start + dal_smem_size; /* Find first chunk header */ cur_header = (struct dal_chunk_header *) (((uint32_t)dal_smem_start + (4095)) & ~4095); *lock = NULL; while (cur_header->size != 0 && ((uint32_t)(cur_header + 1) < (uint32_t)dal_smem_end)) { /* Check if chunk name matches */ if (!strncmp(cur_header->name, chunk_name, DAL_CHUNK_NAME_LENGTH)) { *lock = (_remote_spinlock_t)&cur_header->lock; return 0; } cur_header = (void *)cur_header + cur_header->size; } pr_err("%s: DAL remote lock \"%s\" not found.\n", __func__, chunk_name); return -EINVAL; }
static int check_modem_reset(void) { u32 size; int ret; struct lge_hw_smem_id2_type *smem_id2; smem_id2 = smem_get_entry(SMEM_ID_VENDOR2, &size); if(smem_id2->modem_reset != 1) { return 1; } printk("modem reset command is invoked.\n"); ret = subsys_modem_restart(); smem_id2->modem_reset = 0; wmb(); return ret; }
static int update_apps_boot_mode(void) { static int smem_apps_boot_mode; // LGE_CHANGE_S, [email protected], Don't get the smem data. boot reason is received at lk. #if 1 smem_apps_boot_mode = get_reboot_mode(); #else unsigned smem_size; smem_apps_boot_mode = *(unsigned int *) (smem_get_entry(SMEM_APPS_BOOT_MODE, &smem_size)); #endif // LGE_CHANGE_E, [email protected], Don't get the smem data. boot reason is received at lk. apps_boot_mode = smem_apps_boot_mode; printk(KERN_INFO "[BootMode] apps_boot_mode = 0x%08x\n", apps_boot_mode); return apps_boot_mode; }
static void print_modem_build_id( void ) { struct smem_build_id *modem_build_id; unsigned int build_id_struct_len=0; unsigned msm_version_major = 0, msm_version_minor = 0; #ifdef USE_SMEM modem_build_id = (struct smem_build_id*)smem_get_entry( SMEM_BUILD_ID_LOCATION, &build_id_struct_len ); // cprintf("modem_build_id = %x\n", modem_build_id); if( modem_build_id && build_id_struct_len) { // DISPLAY_MSG("\nMSM Id: %d\n", modem_build_id->msm_id); msm_version_major = (modem_build_id->msm_version >> 16 ) & 0xff; msm_version_minor = modem_build_id->msm_version & 0xff; // DISPLAY_MSG("MSM Version: %d.%d\n", msm_version_major, msm_version_minor); // DISPLAY_MSG("Modem Build Id: %s\n", modem_build_id->build_id); }
void msm_smem_get_cpr_info(struct cpr_info_type *cpr_info) { struct boot_info_for_apps *boot_info; struct cpr_info_type *temp_cpr_info; uint32_t smem_boot_info_size; boot_info = smem_get_entry(SMEM_BOOT_INFO_FOR_APPS, &smem_boot_info_size); BUG_ON(!boot_info); if (smem_boot_info_size < sizeof(struct boot_info_for_apps)) { pr_err("%s: Shared boot info data structure too small!\n", __func__); BUG(); } else { pr_debug("%s: Shared boot info available.\n", __func__); } temp_cpr_info = (struct cpr_info_type *) &(boot_info->cpr_info); cpr_info->ring_osc = temp_cpr_info->ring_osc; cpr_info->turbo_quot = temp_cpr_info->turbo_quot; cpr_info->pvs_fuse = temp_cpr_info->pvs_fuse; }
static void log_modem_sfr(void) { u32 size; char *smem_reason, reason[MAX_SSR_REASON_LEN]; smem_reason = smem_get_entry(SMEM_SSR_REASON_MSS0, &size); if (!smem_reason || !size) { pr_err("modem subsystem failure reason: (unknown, smem_get_entry failed).\n"); return; } if (!smem_reason[0]) { pr_err("modem subsystem failure reason: (unknown, empty string found).\n"); return; } strlcpy(reason, smem_reason, min(size, sizeof(reason))); pr_err("modem subsystem failure reason: %s.\n", reason); smem_reason[0] = '\0'; wmb(); }
static void log_wcnss_sfr(void) { char *smem_reset_reason; unsigned smem_reset_size; smem_reset_reason = smem_get_entry(SMEM_SSR_REASON_WCNSS0, &smem_reset_size); if (!smem_reset_reason || !smem_reset_size) { pr_err("wcnss subsystem failure reason:\n" "(unknown, smem_get_entry failed)"); } else if (!smem_reset_reason[0]) { pr_err("wcnss subsystem failure reason:\n" "(unknown, init string found)"); } else { pr_err("wcnss subsystem failure reason: %.81s\n", smem_reset_reason); memset(smem_reset_reason, 0, smem_reset_size); wmb(); } }
static int debug_read_ch(char *buf, int max) { void *shared, *buffer; unsigned buffer_sz; int n, i = 0; struct smd_alloc_elm *ch_tbl; unsigned ch_type; unsigned shared_size; ch_tbl = smem_find(ID_CH_ALLOC_TBL, sizeof(*ch_tbl) * 64); if (!ch_tbl) goto fail; for (n = 0; n < SMD_CHANNELS; n++) { ch_type = SMD_CHANNEL_TYPE(ch_tbl[n].type); if (is_word_access_ch(ch_type)) shared_size = sizeof(struct smd_half_channel_word_access); else shared_size = sizeof(struct smd_half_channel); shared = smem_find(ID_SMD_CHANNELS + n, 2 * shared_size); if (shared == 0) continue; buffer = smem_get_entry(SMEM_SMD_FIFO_BASE_ID + n, &buffer_sz); if (buffer == 0) continue; i += dump_ch(buf + i, max - i, n, shared, (shared + shared_size), get_half_ch_funcs(ch_type), buffer_sz / 2); } fail: return i; }
/** * Fatal error handler * Resets DSPS. */ static void dsps_restart_handler(struct work_struct *work) { uint32_t dsps_state; int restart_level; char *smem_reset_reason; unsigned smem_reset_size; const char dflt_reason[] = "Died too early due to unknown reason"; dsps_state = smsm_get_state(SMSM_DSPS_STATE); restart_level = get_restart_level(); pr_debug("%s: DSPS state 0x%x. Restart lvl %d\n", __func__, dsps_state, restart_level); if ((dsps_state & SMSM_RESET) || (atomic_read(&drv->wd_crash) == 1)) { smem_reset_reason = smem_get_entry(SMEM_SSR_REASON_DSPS0, &smem_reset_size); if (smem_reset_reason != NULL && smem_reset_reason[0] != 0) { smem_reset_reason[smem_reset_size-1] = 0; pr_err("%s: DSPS failure: %s\nResetting DSPS\n", __func__, smem_reset_reason); memset(smem_reset_reason, 0, smem_reset_size); wmb(); } else pr_err("%s: DSPS failure: %s\nResetting DSPS\n", __func__, dflt_reason); } else pr_err("%s: User-initiated DSPS reset.\nResetting DSPS\n", __func__); if (atomic_add_return(1, &drv->crash_in_progress) > 1) { pr_err("%s: DSPS already resetting. Count %d\n", __func__, atomic_read(&drv->crash_in_progress)); } else { subsystem_restart("dsps"); } }
static int msm_fb_dsi_client_c8680_reset(void) { int rc = 0; unsigned smem_size; unsigned int boot_reason=0; int lcd_en=1; printk("%s: %d\n", __func__, __LINE__); rc = gpio_request(GPIO_C8680_LCD_BACKLIGHT_EN, "gpio_bkl_en"); if (rc < 0) return rc; rc = gpio_tlmm_config(GPIO_CFG(GPIO_C8680_LCD_BACKLIGHT_EN, 0, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA), GPIO_CFG_ENABLE); if (rc < 0) { pr_err("failed GPIO_BACKLIGHT_EN tlmm config\n"); return rc; } //add by fengxiaoli to turn off the lcd when power off rtc boot_reason= *(unsigned int *) (smem_get_entry(SMEM_POWER_ON_STATUS_INFO, &smem_size)); printk(KERN_NOTICE "Boot Reason = %d\n",boot_reason); if (boot_reason==2) lcd_en=0; //end add rc = gpio_direction_output(GPIO_C8680_LCD_BACKLIGHT_EN, lcd_en); if (rc < 0) { pr_err("failed to enable backlight\n"); gpio_free(QRD_GPIO_BACKLIGHT_EN); return rc; } c8680_detect_lcd_panel(); return rc; }
static void log_gss_sfr(void) { u32 size; char *smem_reason, reason[MAX_SSR_REASON_LEN]; smem_reason = smem_get_entry(SMEM_SSR_REASON_MSS0, &size); if (!smem_reason || !size) { pr_err("GSS subsystem failure reason: (unknown, smem_get_entry failed).\n"); return; } if (!smem_reason[0]) { pr_err("GSS subsystem failure reason: (unknown, init string found).\n"); return; } size = min(size, MAX_SSR_REASON_LEN-1); memcpy(reason, smem_reason, size); reason[size] = '\0'; pr_err("GSS subsystem failure reason: %s.\n", reason); smem_reason[0] = '\0'; wmb(); }