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");
}
Exemplo n.º 3
0
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);
}
Exemplo n.º 5
0
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;
}
Exemplo n.º 6
0
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);
}
Exemplo n.º 7
0
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 (;;)
		;
}
Exemplo n.º 8
0
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;
}
Exemplo n.º 10
0
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);

}
Exemplo n.º 11
0
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;
}
Exemplo n.º 13
0
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);

}
Exemplo n.º 14
0
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 (;;)
		;
}
Exemplo n.º 15
0
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;
}
Exemplo n.º 16
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);
}
Exemplo n.º 18
0
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);
}
Exemplo n.º 19
0
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);
	}
}
Exemplo n.º 20
0
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;
}
Exemplo n.º 23
0
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;
}
Exemplo n.º 25
0
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();
	}
}
Exemplo n.º 27
0
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;
}
Exemplo n.º 28
0
/**
 *  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;
}
Exemplo n.º 30
0
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();
}