Beispiel #1
0
static inline int pc_clk_set_flags(unsigned id, unsigned flags)
{
	return msm_proc_comm(PCOM_CLKCTL_RPC_SET_FLAGS, &id, &flags);
}
Beispiel #2
0
int vreg_disable(unsigned id)
{
	unsigned int enable = 0;
	return msm_proc_comm(PCOM_VREG_SWITCH, &id, &enable);
}
Beispiel #3
0
void vreg_disable(struct vreg *vreg)
{
	unsigned id = vreg->id;
	unsigned enable = 0;
	msm_proc_comm(PCOM_VREG_SWITCH, &id, &enable);
}
Beispiel #4
0
static int clock_set_rate(unsigned id, unsigned rate)
{
	return msm_proc_comm(PCOM_CLKCTL_RPC_SET_RATE, &id, &rate);
}
Beispiel #5
0
int gpio_tlmm_config(unsigned config, unsigned disable)
{
	return msm_proc_comm(PCOM_RPC_GPIO_TLMM_CONFIG_EX, &config, &disable);
}
Beispiel #6
0
static ssize_t reset_modem_write(struct file *fp, const char __user *buf,
			 size_t count, loff_t *pos)
{
	unsigned char cmd[64];
	int len;
	int time;
	int zero = 0;
	int r;

	if (count < 1)
		return 0;

	len = count > 63 ? 63 : count;

	if (copy_from_user(cmd, buf, len))
		return -EFAULT;

	cmd[len] = 0;

	/* lazy */
	if (cmd[len-1] == '\n') {
		cmd[len-1] = 0;
		len--;
	}

	if (!strncmp(cmd, "wait", 4)) {
		D(KERN_ERR "INFO:%s:%i:%s: "
		       "MODEM RESTART: WAIT\n",
		       __FILE__,
		       __LINE__,
		       __func__);
		smsm_reset_modem(SMSM_MODEM_WAIT);
	} else if (!strncmp(cmd, "continue", 8)) {
		D(KERN_ERR "INFO:%s:%i:%s: "
		       "MODEM RESTART: CONTINUE\n",
		       __FILE__,
		       __LINE__,
		       __func__);
		smsm_reset_modem_cont();
	} else if (!strncmp(cmd, "download", 8)) {
		D(KERN_ERR "INFO:%s:%i:%s: "
		       "MODEM RESTART: DOWNLOAD\n",
		       __FILE__,
		       __LINE__,
		       __func__);
		smsm_reset_modem(SMSM_SYSTEM_DOWNLOAD);
	} else if (sscanf(cmd, "deferred reset %i", &time) == 1) {
		D(KERN_ERR "INFO:%s:%i:%s: "
		       "MODEM RESTART: DEFERRED RESET %ims\n",
		       __FILE__,
		       __LINE__,
		       __func__,
		       time);
		if (time == 0) {
			r = 0;
			msm_proc_comm_reset_modem_now();
		} else {
			r = msm_proc_comm(PCOM_RESET_MODEM, &time, &zero);
		}
		if (r < 0)
			return r;
	} else if (!strncmp(cmd, "deferred reset", 14)) {
		D(KERN_ERR "INFO:%s:%i:%s: "
		       "MODEM RESTART: DEFERRED RESET 0ms\n",
		       __FILE__,
		       __LINE__,
		       __func__);
		r = 0;
		msm_proc_comm_reset_modem_now();
		if (r < 0)
			return r;
	} else if (!strncmp(cmd, "reset chip now", 14)) {
#ifndef CONFIG_SW_RESET
		uint param1 = 0x0;
		uint param2 = 0x0;
#endif
		D(KERN_ERR "INFO:%s:%i:%s: "
		  "MODEM RESTART: CHIP RESET IMMEDIATE\n",
		  __FILE__,
		  __LINE__,
		  __func__);

#if defined(CONFIG_SW_RESET)
		r = sky_sys_rst_UserReset_imm(NULL);
#else
		r = msm_proc_comm(PCOM_RESET_CHIP_IMM, &param1, &param2);
#endif

		if (r < 0)
			return r;
	} else if (!strncmp(cmd, "reset chip", 10)) {
#ifndef CONFIG_SW_RESET		
		uint param1 = 0x0;
		uint param2 = 0x0;
#endif
		D(KERN_ERR "INFO:%s:%i:%s: "
		  "MODEM RESTART: CHIP RESET \n",
		  __FILE__,
		  __LINE__,
		  __func__);

#if defined(CONFIG_SW_RESET)
		r = sky_sys_rst_UserReset(NULL);
#else
		r = msm_proc_comm(PCOM_RESET_CHIP, &param1, &param2);
#endif

		if (r < 0)
			return r;
#if defined(CONFIG_SW_RESET)
	} else if (!strncmp(cmd, "reset sw now", 12)) {

		D(KERN_ERR "INFO:%s:%i:%s: "
		  "MODEM SW RESTART: CHIP RESET IMMEDIATE\n",
		  __FILE__,
		  __LINE__,
		  __func__);

		r = sky_sys_rst_SwReset_imm(NULL);

		if (r < 0)
		{
			D(KERN_ERR "ERROR: sky_sys_rst_SwReset_imm failed: %d\n", r);
			return r;
		}
	} else if (!strncmp(cmd, "reset sw exception", 8)) {

		D(KERN_ERR "INFO:%s:%i:%s: "
		  "MODEM SW RESTART: CHIP EXCEPTION \n",
		  __FILE__,
		  __LINE__,
		  __func__);

		BUG();
		return 0;

#endif
	} else if (!strncmp(cmd, "reset", 5)) {
		printk(KERN_ERR "INFO:%s:%i:%s: "
		       "MODEM RESTART: RESET\n",
		       __FILE__,
		       __LINE__,
		       __func__);
		smsm_reset_modem(SMSM_RESET);
	} 
#ifdef FEATURE_SKY_CHG_LOGO
	else if(!strncmp(cmd,"powerdown",9)) {

		printk(KERN_ERR "INFO:%s:%i:%s: "
		       "MODEM POWER DOWN: OFF\n",
		       __FILE__,
		       __LINE__,
		       __func__);
		
		r = msm_proc_comm(PCOM_POWER_DOWN, 0,0);

		if (r < 0)
			return r;

		for(;;)
			;
	}
#endif
	else
		return -EINVAL;

	return count;
}
void pc_clk_disable(unsigned id)
{
	msm_proc_comm(PCOM_CLKCTL_RPC_DISABLE, &id, NULL);
}
static ssize_t reset_modem_write(struct file *fp, const char __user *buf,
			 size_t count, loff_t *pos)
{
	unsigned char cmd[64];
	int len;
	int time;
	int zero = 0;
	int r;

	if (count < 1)
		return 0;

	len = count > 63 ? 63 : count;

	if (copy_from_user(cmd, buf, len))
		return -EFAULT;

	cmd[len] = 0;

	/* lazy */
	if (cmd[len-1] == '\n') {
		cmd[len-1] = 0;
		len--;
	}

	if (!strncmp(cmd, "wait", 4)) {
		D(KERN_ERR "INFO:%s:%i:%s: "
		       "MODEM RESTART: WAIT\n",
		       __FILE__,
		       __LINE__,
		       __func__);
		smsm_reset_modem(SMSM_MODEM_WAIT);
	} else if (!strncmp(cmd, "continue", 8)) {
		D(KERN_ERR "INFO:%s:%i:%s: "
		       "MODEM RESTART: CONTINUE\n",
		       __FILE__,
		       __LINE__,
		       __func__);
		smsm_reset_modem_cont();
	} else if (!strncmp(cmd, "download", 8)) {
		D(KERN_ERR "INFO:%s:%i:%s: "
		       "MODEM RESTART: DOWNLOAD\n",
		       __FILE__,
		       __LINE__,
		       __func__);
		smsm_reset_modem(SMSM_SYSTEM_DOWNLOAD);
	} else if (sscanf(cmd, "deferred reset %i", &time) == 1) {
		D(KERN_ERR "INFO:%s:%i:%s: "
		       "MODEM RESTART: DEFERRED RESET %ims\n",
		       __FILE__,
		       __LINE__,
		       __func__,
		       time);
		if (time == 0) {
			r = 0;
			msm_proc_comm_reset_modem_now();
		} else {
			r = msm_proc_comm(PCOM_RESET_MODEM, &time, &zero);
		}
		if (r < 0)
			return r;
	} else if (!strncmp(cmd, "deferred reset", 14)) {
		D(KERN_ERR "INFO:%s:%i:%s: "
		       "MODEM RESTART: DEFERRED RESET 0ms\n",
		       __FILE__,
		       __LINE__,
		       __func__);
		r = 0;
		msm_proc_comm_reset_modem_now();
	} else if (!strncmp(cmd, "reset chip now", 14)) {
		uint param1 = 0x0;
		uint param2 = 0x0;

		D(KERN_ERR "INFO:%s:%i:%s: "
		  "MODEM RESTART: CHIP RESET IMMEDIATE\n",
		  __FILE__,
		  __LINE__,
		  __func__);

		r = msm_proc_comm(PCOM_RESET_CHIP_IMM, &param1, &param2);

		if (r < 0)
			return r;
	} else if (!strncmp(cmd, "reset chip", 10)) {

		uint param1 = 0x0;
		uint param2 = 0x0;

		D(KERN_ERR "INFO:%s:%i:%s: "
		  "MODEM RESTART: CHIP RESET \n",
		  __FILE__,
		  __LINE__,
		  __func__);

		r = msm_proc_comm(PCOM_RESET_CHIP, &param1, &param2);

		if (r < 0)
			return r;
	} else if (!strncmp(cmd, "reset", 5)) {
		printk(KERN_ERR "INFO:%s:%i:%s: "
		       "MODEM RESTART: RESET\n",
		       __FILE__,
		       __LINE__,
		       __func__);
		smsm_reset_modem(SMSM_RESET);
	} else
		return -EINVAL;

	return count;
}
Beispiel #9
0
// Cotullaz "new" clock functions
static int cotulla_clk_set_rate(uint32_t id, unsigned long rate)
{
    unsigned clk = -1;
    unsigned speed = 0;
    switch (id) {
		case ICODEC_RX_CLK:
			if (rate > 11289600)     speed = 9;
			else if (rate > 8192000) speed = 8;
			else if (rate > 6144000) speed = 7;
			else if (rate > 5644800) speed = 6;
			else if (rate > 4096000) speed = 5;
			else if (rate > 3072000) speed = 4;
			else if (rate > 2822400) speed = 3;
			else if (rate > 2048000) speed = 2;
			else speed = 1;
			clk = 50;
			break;
		case ICODEC_TX_CLK:
			if (rate > 11289600) 	 speed = 9;
			else if (rate > 8192000) speed = 8;
			else if (rate > 6144000) speed = 7;
			else if (rate > 5644800) speed = 6;
			else if (rate > 4096000) speed = 5;
			else if (rate > 3072000) speed = 4;
			else if (rate > 2822400) speed = 3;
			else if (rate > 2048000) speed = 2;
			else speed = 1;
			clk = 52;
			break;
		case SDAC_MCLK:
			if (rate > 1411200) 	speed = 9;
			else if (rate > 1024000)speed = 8;
			else if (rate > 768000) speed = 7;
			else if (rate > 705600) speed = 6;
			else if (rate > 512000) speed = 5;
			else if (rate > 384000) speed = 4;
			else if (rate > 352800) speed = 3;
			else if (rate > 256000) speed = 2;
			else speed = 1;
			clk = 64;
			break;
		case UART1DM_CLK:
			if (rate > 61440000) 	  speed = 15;
			else if (rate > 58982400) speed = 14;
			else if (rate > 56000000) speed = 13;
			else if (rate > 51200000) speed = 12;
			else if (rate > 48000000) speed = 11;
			else if (rate > 40000000) speed = 10;
			else if (rate > 32000000) speed = 9;
			else if (rate > 24000000) speed = 8;
			else if (rate > 16000000) speed = 7;
			else if (rate > 15360000) speed = 6;
			else if (rate > 14745600) speed = 5;
			else if (rate >  7680000) speed = 4;
			else if (rate >  7372800) speed = 3;
			else if (rate >  3840000) speed = 2;
			else speed = 1;
			clk = 78;
			break;
		case UART2DM_CLK:
			if (rate > 61440000) 	  speed = 15;
			else if (rate > 58982400) speed = 14;
			else if (rate > 56000000) speed = 13;
			else if (rate > 51200000) speed = 12;
			else if (rate > 48000000) speed = 11;
			else if (rate > 40000000) speed = 10;
			else if (rate > 32000000) speed = 9;
			else if (rate > 24000000) speed = 8;
			else if (rate > 16000000) speed = 7;
			else if (rate > 15360000) speed = 6;
			else if (rate > 14745600) speed = 5;
			else if (rate >  7680000) speed = 4;
			else if (rate >  7372800) speed = 3;
			else if (rate >  3840000) speed = 2;
			else speed = 1;
			clk = 80;
			break;
		case ECODEC_CLK:
			if (rate > 2048000) 	speed = 3;
			else if (rate > 128000) speed = 2;
			else speed = 1;
			clk = 42;
			break;
		case VFE_MDC_CLK:
			if (rate == 96000000) 		speed = 37;
			else if (rate == 48000000)	speed = 32;
			else if (rate == 24000000) 	speed = 22;
			else if (rate == 12000000) 	speed = 14;
			else if (rate ==  6000000) 	speed = 6;
			else if (rate ==  3000000) 	speed = 1;
			else return 0;
			clk = 40;
			break;
		case VFE_CLK:
			if (rate == 36000000) 		speed = 1;
			else if (rate == 48000000) 	speed = 2;
			else if (rate == 64000000) 	speed = 3;
			else if (rate == 78000000) 	speed = 4;
			else if (rate == 96000000) 	speed = 5;
			else return 0;
			clk = 41;
			break;
		case SPI_CLK:
			if (rate > 15360000) 		speed = 5;
			else if (rate > 9600000) 	speed = 4;
			else if (rate > 4800000) 	speed = 3;
			else if (rate >  960000) 	speed = 2;
			else speed = 1;
			clk = 95;
			break;
		case SDC1_CLK:
			if (rate > 50000000) 		speed = 14;
			else if (rate > 49152000) 	speed = 13;
			else if (rate > 45000000) 	speed = 12;
			else if (rate > 40000000) 	speed = 11;
			else if (rate > 35000000) 	speed = 10;
			else if (rate > 30000000) 	speed = 9;
			else if (rate > 25000000) 	speed = 8;
			else if (rate > 20000000) 	speed = 7;
			else if (rate > 15000000) 	speed = 6;
			else if (rate > 10000000) 	speed = 5;
			else if (rate > 5000000)  	speed = 4;
			else if (rate > 400000)		speed = 3;
			else if (rate > 144000)		speed = 2;
			else speed = 1;
			clk = 66;
			break;
		case SDC2_CLK:
			if (rate > 50000000) 		speed = 14;
			else if (rate > 49152000) 	speed = 13;
			else if (rate > 45000000) 	speed = 12;
			else if (rate > 40000000) 	speed = 11;
			else if (rate > 35000000) 	speed = 10;
			else if (rate > 30000000) 	speed = 9;
			else if (rate > 25000000) 	speed = 8;
			else if (rate > 20000000) 	speed = 7;
			else if (rate > 15000000) 	speed = 6;
			else if (rate > 10000000) 	speed = 5;
			else if (rate > 5000000)  	speed = 4;
			else if (rate > 400000)		speed = 3;
			else if (rate > 144000)		speed = 2;
			else speed = 1;
			clk = 67;
			break;
		case SDC1_PCLK:
		case SDC2_PCLK:
			return 0;
			break;
		default:
			return -1;  
    }
    msm_proc_comm(PCOM_CLK_REGIME_SEC_SEL_SPEED, &clk, &speed);
	
    return 0;
}
Beispiel #10
0
void gpio_set_diag_gpio_table(unsigned long *dwMFG_gpio_table)
{
	int i = 0;
	unsigned cfg;
	PSUSPEND_PIN_CONFIG pSuspendPinConfig = 0;

	pSuspendPinConfig = (PSUSPEND_PIN_CONFIG)(dwMFG_gpio_table);
#if defined(CONFIG_ARCH_MSM7X00A)
	for (i = 0; i <= 121; i++)
#elif defined(CONFIG_ARCH_MSM7225)
	for (i = 0; i < 132; i++)
#elif defined(CONFIG_ARCH_MSM7227)
	for (i = 0; i < 132; i++)
#elif defined(CONFIG_ARCH_QSD8X50)
	for (i = 0; i <= 164; i++)
#elif defined(CONFIG_ARCH_MSM7X30)
	for (i = 0; i <= 181; i++)
#elif defined(CONFIG_ARCH_MSM8X60)
	for (i = 0; i < 173; i++)
#elif defined(CONFIG_ARCH_MSM8960)
	for (i = 0; i < 151; i++)
#endif
	{
		unsigned char tempGpio = pSuspendPinConfig->arGpio[i];

		if (tempGpio & 0x1) {
			/* configure by the settings from DIAG */
			unsigned long dwGpioKind, dwGpioConfig, dwOutputLevel;
			if (tempGpio & 0x2) { /* GPIO INPUT PIN */
				dwGpioKind = GPIO_INPUT;
				dwOutputLevel = 0;
			} else { /* GPIO_OUTPUT_PIN */
				dwGpioKind = GPIO_OUTPUT;
				if (tempGpio & 0x4)
					dwOutputLevel = 1;
				else
					dwOutputLevel = 0;
			}

			/* config GpioPullStatus */
			if ((tempGpio & 0x10) && (tempGpio & 0x08))
				dwGpioConfig = GPIO_PULL_UP;
			else if (tempGpio & 0x08)
				dwGpioConfig = GPIO_PULL_DOWN;
			else if (tempGpio & 0x10)
				dwGpioConfig = GPIO_KEEPER;
			else
				dwGpioConfig = GPIO_NO_PULL;

#if defined(CONFIG_ARCH_MSM8X60) || defined(CONFIG_ARCH_MSM8960)
			cfg = GPIO_CFG(i, 0, dwGpioKind, dwGpioConfig, GPIO_2MA);
			gpio_tlmm_config(cfg, GPIO_CFG_ENABLE);
#else
			cfg = PCOM_GPIO_CFG(i, 0, dwGpioKind, dwGpioConfig, GPIO_2MA);

			msm_proc_comm(PCOM_RPC_GPIO_TLMM_CONFIG_EX, &cfg, 0);
#endif
			if (dwGpioKind == GPIO_OUTPUT)
				gpio_direction_output(i, dwOutputLevel);
		} else {
			/* DIAG does not want to config this GPIO */
			continue;
		}
	}
}
static void msm_pm_power_off(void)
{
	msm_proc_comm(PCOM_POWER_DOWN, 0, 0);
	for (;;)
		;
}
int proc_comm_rpc_apps_to_modem(unsigned sub_cmd, unsigned *data)
{
	return msm_proc_comm(PCOM_CUSTOMER_CMD2, &sub_cmd, data);
}
Beispiel #13
0
static long snd_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
	struct snd_set_device_msg dmsg;
	struct snd_set_volume_msg vmsg;
	struct snd_avc_ctl_msg avc_msg;
	struct snd_agc_ctl_msg agc_msg;
	struct snd_set_extamp_msg emsg;

	struct msm_snd_device_config dev;
	struct msm_snd_volume_config vol;
	struct msm_snd_extamp_config extamp;
	struct snd_ctxt *snd = file->private_data;
	int rc = 0;

	uint32_t avc, agc;

#ifdef FEATURE_MAX8899_AMP_OFF
	int data1 = 0;
	int data2 = 0;
#endif
	mutex_lock(&snd->lock);
	switch (cmd) {
	case SND_SET_DEVICE:
		if (copy_from_user(&dev, (void __user *) arg, sizeof(dev))) {
			MM_ERR("set device: invalid pointer\n");
			rc = -EFAULT;
			break;
		}

		dmsg.args.device = cpu_to_be32(dev.device);
		dmsg.args.ear_mute = cpu_to_be32(dev.ear_mute);
		dmsg.args.mic_mute = cpu_to_be32(dev.mic_mute);
		if (check_mute(dev.ear_mute) < 0 ||
				check_mute(dev.mic_mute) < 0) {
			MM_ERR("set device: invalid mute status\n");
			rc = -EINVAL;
			break;
		}
		dmsg.args.cb_func = -1;
		dmsg.args.client_data = 0;

		//MM_INFO("snd_set_device %d %d %d\n", dev.device,
		//		dev.ear_mute, dev.mic_mute);

		rc = msm_rpc_call(snd->ept,
			SND_SET_DEVICE_PROC,
			&dmsg, sizeof(dmsg), 5 * HZ);
		break;

	case SND_SET_VOLUME:
		if (copy_from_user(&vol, (void __user *) arg, sizeof(vol))) {
			MM_ERR("set volume: invalid pointer\n");
			rc = -EFAULT;
			break;
		}

		vmsg.args.device = cpu_to_be32(vol.device);
		vmsg.args.method = cpu_to_be32(vol.method);
		if (vol.method != SND_METHOD_VOICE) {
			MM_ERR("set volume: invalid method\n");
			rc = -EINVAL;
			break;
		}

		vmsg.args.volume = cpu_to_be32(vol.volume);
		vmsg.args.cb_func = -1;
		vmsg.args.client_data = 0;

		MM_INFO("snd_set_volume %d %d %d\n", vol.device,
				vol.method, vol.volume);

		rc = msm_rpc_call(snd->ept,
			SND_SET_VOLUME_PROC,
			&vmsg, sizeof(vmsg), 5 * HZ);
		break;

	case SND_AVC_CTL:
		if (get_user(avc, (uint32_t __user *) arg)) {
			rc = -EFAULT;
			break;
		} else if ((avc != 1) && (avc != 0)) {
			rc = -EINVAL;
			break;
		}

		avc_msg.args.avc_ctl = cpu_to_be32(avc);
		avc_msg.args.cb_func = -1;
		avc_msg.args.client_data = 0;

		MM_INFO("snd_avc_ctl %d\n", avc);

		rc = msm_rpc_call(snd->ept,
			SND_AVC_CTL_PROC,
			&avc_msg, sizeof(avc_msg), 5 * HZ);
		break;

	case SND_AGC_CTL:
		if (get_user(agc, (uint32_t __user *) arg)) {
			rc = -EFAULT;
			break;
		} else if ((agc != 1) && (agc != 0)) {
			rc = -EINVAL;
			break;
		}
		agc_msg.args.agc_ctl = cpu_to_be32(agc);
		agc_msg.args.cb_func = -1;
		agc_msg.args.client_data = 0;

		MM_INFO("snd_agc_ctl %d\n", agc);

		rc = msm_rpc_call(snd->ept,
			SND_AGC_CTL_PROC,
			&agc_msg, sizeof(agc_msg), 5 * HZ);
		break;

	case SND_GET_NUM_ENDPOINTS:
		if (copy_to_user((void __user *)arg,
				&snd->snd_epts->num, sizeof(unsigned))) {
			MM_ERR("get endpoint: invalid pointer\n");
			rc = -EFAULT;
		}
		break;

	case SND_GET_ENDPOINT:
		rc = get_endpoint(snd, arg);
		break;

	case SND_SET_EXTAMP:
		if (copy_from_user(&extamp, (void __user *) arg, sizeof(extamp))) {
			MM_ERR("set extamp: invalid pointer\n");
			rc = -EFAULT;
			break;
		}

		emsg.args.device = cpu_to_be32(extamp.device);
		emsg.args.speaker_volume = cpu_to_be32(extamp.speaker_volume);
		emsg.args.headset_volume = cpu_to_be32(extamp.headset_volume);
		emsg.args.cb_func = -1;
		emsg.args.client_data = 0;
		emsg.args.update_amp_gain = cpu_to_be32(extamp.update_amp_gain);  //HYH_20110511

		MM_ERR("snd_set_extamp %d %d %d\n", extamp.device,
				extamp.speaker_volume, extamp.headset_volume);

		rc = msm_rpc_call(snd->ept,
			SND_SET_EXTAMP_PROC,
			&emsg, sizeof(emsg), 5 * HZ);
		break;
		
#if 0 // don't use gpio for mic selection	
	case SND_SET_MAIN_MIC:
		rc = gpio_direction_output(89, 1);
		break;
	case SND_SET_SUB_MIC:
		rc = gpio_direction_output(89, 0);
		break;
#endif 

#ifdef FEATURE_MAX8899_AMP_OFF
	case SND_MAX8899_AMP_OFF:
		if (copy_from_user(&data1, (void __user *) arg, sizeof(data1))) {
			MM_ERR("amp off: invalid pointer\n");
			rc = -EFAULT;
			break;
		}
		rc = msm_proc_comm(SMEM_PROC_COMM_AMP_OFF, &data1, &data2);
		if(rc < 0)
		{
			printk("%s max8899 amp off proccomm fail\n", __func__);
			return rc;
		}
		MM_ERR("snd_max8899_amp_off %d\n", data1);
		break;
#endif
	default:
		MM_ERR("unknown command %d\n", cmd);
		rc = -EINVAL;
		break;
	}
	mutex_unlock(&snd->lock);

	return rc;
}
Beispiel #14
0
int vreg_set_level(struct vreg *vreg, unsigned mv)
{
	unsigned id = vreg->id;
	return msm_proc_comm(PCOM_VREG_SET_LEVEL, &id, &mv);
}
Beispiel #15
0
static inline int pc_pll_request(unsigned id, unsigned on)
{
	on = !!on;
	return msm_proc_comm(PCOM_CLKCTL_RPC_PLL_REQUEST, &id, &on);
}
Beispiel #16
0
static int cotulla_clk_disable(uint32_t id)
{
    unsigned clk = -1;
    switch (id) {
		case ICODEC_RX_CLK:
			clk = 50;
			break;
		case ICODEC_TX_CLK:
			clk = 52;
			break;
		case ECODEC_CLK:
			clk = 42;
			break;   
		case SDAC_MCLK:
			clk = 64;
			break;
		case IMEM_CLK:
			clk = 55;
			break;
		case GRP_CLK:
			clk = 56;
			break;
		case ADM_CLK:
			clk = 19;
			break;
		case UART1DM_CLK:
			clk = 78;
			break;
		case UART2DM_CLK:
			clk = 80;
			break;
		case VFE_AXI_CLK:
			clk = 24;
			break;
		case VFE_MDC_CLK:
			clk = 40;
			break;
		case VFE_CLK:
			clk = 41;
			break;
		case MDC_CLK:
			clk = 53; // WTF??
			break;
		case SPI_CLK:
			clk = 95;
			break;
		case MDP_CLK:
			clk = 9;
			break;
		case SDC1_CLK:
			clk = 66;
			break;
		case SDC2_CLK:
			clk = 67;
			break;
		case SDC1_PCLK:
			clk = 17;
			break;
		case SDC2_PCLK:
			clk = 16;
			break;
		default:
			return -1;  
    }
    msm_proc_comm(PCOM_CLK_REGIME_SEC_DISABLE, &clk, 0);
	
    return 0;
}
/*
 * In boot loader, mddi is powered on already.
 *
 * So, we just detect panel here, setting different
 * power function for each panel.
 *
 * Then we did not have to detect panel in each time
 * mddi_client_power or panel_power is called.
 *
 * jay: Nov 20, 08'
 */
int __init chacha_init_panel(void)
{
	int rc;
	int panel_type = 0;
	int panel_id = -1;
	int gpio_lcd_id0, gpio_lcd_id1;
	uint32_t config;
	struct panel_data *panel_data = &renesas_AUO_client_data.panel_conf;
	struct msm_mddi_client_data *client = renesas.client_data;

	B(KERN_INFO "%s: enter.\n", __func__);

	vreg_lcm_2v6 = vreg_get(0, "gp4");
	if (IS_ERR(vreg_lcm_2v6))
		return PTR_ERR(vreg_lcm_2v6);

	vreg_lcm_2v85 = vreg_get(0, "rfrx2");
	if (IS_ERR(vreg_lcm_2v85))
		return PTR_ERR(vreg_lcm_2v85);

	gpio_lcd_id0 =  PCOM_GPIO_CFG(CHACHA_GPIO_LCD_ID0, 0, GPIO_INPUT, GPIO_NO_PULL, GPIO_2MA);
	gpio_lcd_id1 =  PCOM_GPIO_CFG(CHACHA_GPIO_LCD_ID1, 0, GPIO_INPUT, GPIO_NO_PULL, GPIO_2MA);
	msm_proc_comm(PCOM_RPC_GPIO_TLMM_CONFIG_EX, &gpio_lcd_id0, 0);
	msm_proc_comm(PCOM_RPC_GPIO_TLMM_CONFIG_EX, &gpio_lcd_id1, 0);

	panel_id = gpio_get_value(CHACHA_GPIO_LCD_ID0) |
	           (gpio_get_value(CHACHA_GPIO_LCD_ID1) << 1);

	B(KERN_INFO "%s: panel_id:%d.\n", __func__,panel_id);

	switch(panel_id) {
		case 0:
			panel_type = 10;
			panel_data = &renesas_liberty_client_data.panel_conf;
		break;

		case 1:
			panel_type = 13;
			panel_data = &renesas_AUO_client_data.panel_conf;
		break;
		default:
			chacha_mddi_renesas_power(client, 0);
			gpio_lcd_id0 =  PCOM_GPIO_CFG(CHACHA_GPIO_LCD_ID0, 0,
						GPIO_OUTPUT, GPIO_NO_PULL, GPIO_2MA);
			gpio_lcd_id1 =  PCOM_GPIO_CFG(CHACHA_GPIO_LCD_ID1, 0,
						GPIO_OUTPUT, GPIO_NO_PULL, GPIO_2MA);
			msm_proc_comm(PCOM_RPC_GPIO_TLMM_CONFIG_EX, &gpio_lcd_id0, 0);
			msm_proc_comm(PCOM_RPC_GPIO_TLMM_CONFIG_EX, &gpio_lcd_id1, 0);
		break;
	}

	panel_data->panel_id = panel_type;
	panel_data->caps = MSMFB_CAP_CABC;
	panel_data->pwm = pwm_renesas;
	panel_data->shrink = 1;
	panel_data->shrink_br = chacha_panel_shrink;
	panel_data->default_br = 83;

	config = PCOM_GPIO_CFG(CHACHA_GPIO_MDDI_TE, 1, GPIO_INPUT, GPIO_PULL_DOWN, GPIO_2MA);
	msm_proc_comm(PCOM_RPC_GPIO_TLMM_CONFIG_EX, &config, 0);

	msm_device_mdp.dev.platform_data = &chacha_mdp_pdata;
	rc = platform_device_register(&msm_device_mdp);
	if (rc)
		return rc;

	msm_device_mddi0.dev.platform_data = &chacha_pdata;
	rc = platform_device_register(&msm_device_mddi0);
	if (rc)
		return rc;

	led_trigger_register_simple("lcd-backlight-gate", &chacha_lcd_backlight);
	if (IS_ERR(chacha_lcd_backlight))
		printk(KERN_ERR "[BKL] %s: backlight registration failed!\n",
			__func__);
	return 0;
}
Beispiel #18
0
static long cotulla_clk_get_rate(uint32_t id)
{
    unsigned clk = -1;
    unsigned rate;
    switch (id) {
		case ICODEC_RX_CLK:
			clk = 50;
			break;
		case ICODEC_TX_CLK:
			clk = 52;
			break;
		case ECODEC_CLK:
			clk = 42;
			break;
		case SDAC_MCLK:
			clk = 64;
			break;
		case IMEM_CLK:
			clk = 55;
			break;
		case GRP_CLK:
			clk = 56;
			break;
		case ADM_CLK:
			clk = 19;
			break;
		case UART1DM_CLK:
			clk = 78;
			break;
		case UART2DM_CLK:
			clk = 80;
			break;
		case VFE_AXI_CLK:
			clk = 24;
			break;
		case VFE_MDC_CLK:
			clk = 40;
			break;
		case VFE_CLK:
			clk = 41;
			break;
		case MDC_CLK:
			clk = 53; // ??
			break;
		case SPI_CLK:
			clk = 95;
			break;
		case MDP_CLK:
			clk = 9;
			break;
		case SDC1_CLK:
			clk = 66;
			break;
		case SDC2_CLK:
			clk = 67;
			break;
		case SDC1_PCLK:
			clk = 17;
			break;
		case SDC2_PCLK:
			clk = 16;
			break;
		default:
			return 0;
    }
    msm_proc_comm(PCOM_CLK_REGIME_SEC_MSM_GET_CLK_FREQ_KHZ, &clk, &rate);
	
    return clk*1000;
}
Beispiel #19
0
static long snd_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
	struct snd_set_device_msg dmsg;
	struct snd_set_volume_msg vmsg;
	struct snd_avc_ctl_msg avc_msg;
	struct snd_agc_ctl_msg agc_msg;

	struct msm_snd_device_config dev;
	struct msm_snd_volume_config vol;
	struct snd_ctxt *snd = file->private_data;
	int rc = 0;

	int data1, data2;

	uint32_t avc, agc;

	mutex_lock(&snd->lock);
	switch (cmd) {
	case SND_SET_DEVICE:
		if (copy_from_user(&dev, (void __user *) arg, sizeof(dev))) {
			MM_ERR("set device: invalid pointer\n");
			rc = -EFAULT;
			break;
		}

		dmsg.args.device = cpu_to_be32(dev.device);
		dmsg.args.ear_mute = cpu_to_be32(dev.ear_mute);
		dmsg.args.mic_mute = cpu_to_be32(dev.mic_mute);
		dev.bluetooth_id = 0;
		dmsg.args.bluetooth_id = cpu_to_be32(dev.bluetooth_id);
		if (check_mute(dev.ear_mute) < 0 ||
				check_mute(dev.mic_mute) < 0) {
			MM_ERR("set device: invalid mute status\n");
			rc = -EINVAL;
			break;
		}
		dmsg.args.cb_func = -1;
		dmsg.args.client_data = 0;

		MM_INFO("snd_set_device %d %d %d\n", dev.device,
				dev.ear_mute, dev.mic_mute);
		//printk("[Aaron][%s] snd_set_device %d %d %d\r\n", __func__, dev.device,
		//		dev.ear_mute, dev.mic_mute);

		rc = msm_rpc_call(snd->ept,
			SND_SET_DEVICE_PROC,
			&dmsg, sizeof(dmsg), 5 * HZ);
		//printk("[Aaron][%s] rc=%x\r\n", __func__, rc);
		break;

	case SND_SET_VOLUME:
		if (copy_from_user(&vol, (void __user *) arg, sizeof(vol))) {
			MM_ERR("set volume: invalid pointer\n");
			rc = -EFAULT;
			break;
		}

		vmsg.args.device = cpu_to_be32(vol.device);
		vmsg.args.method = cpu_to_be32(vol.method);
		if (vol.method != SND_METHOD_VOICE) {
			MM_ERR("set volume: invalid method\n");
			rc = -EINVAL;
			break;
		}

		// Uper layer will send volume as 0,1,3,4,6,7
		// But L1 level is 0~6, 6=7.
		// We do not want 0 as mute, so shift 0 to 1.
		// Aaron Chen 2010.08.23
		if ((vol.device != 33) && (vol.device != 34))//FM needs volume 0 for mute brad 
		{
		    if (vol.volume == 0)
		    {
			vol.volume = 1;
		    }
		    else if (vol.volume == 1)
		    {
			vol.volume = 2;
		    }
		    else if (vol.volume == 6)
		    {
			vol.volume = 5;
		    }
		    else if (vol.volume == 7)
		    {
			vol.volume = 6;
		    }
		}
		vmsg.args.volume = cpu_to_be32(vol.volume);
		vmsg.args.cb_func = -1;
		vmsg.args.client_data = 0;

		MM_INFO("snd_set_volume %d %d %d\n", vol.device,
				vol.method, vol.volume);
		//printk("[Aaron][%s] snd_set_volume %d %d %d %d\r\n", __func__, vol.device, vol.method, vol.volume, vmsg.args.volume);

		//printk("[Aaron][%s] PCOM_CCI_SET_AUX_PGA_GAIN(138)=%d\r\n", __func__, PCOM_CCI_SET_AUX_PGA_GAIN);
		if ((vol.device == 33) || (vol.device == 34))
		{
			#if 0
			data1 = 0;
			data2 = 3000;
			rc = msm_proc_comm(PCOM_CCI_VIBRATE, &data1, &data2);
			printk("[Aaron][%s] msm_proc_comm(PCOM_CCI_VIBRATE, 7, 0) rc=%d\r\n", __func__, rc);
			#endif
			
			data1 = vol.volume;
			data2 = vol.volume;
			rc = msm_proc_comm(PCOM_CCI_SET_AUX_PGA_GAIN, &data1, &data2);
			//printk("[Aaron][%s] msm_proc_comm(PCOM_CCI_SET_AUX_PGA_GAIN, 7, 0) rc=%d\r\n", __func__, rc);
		}

		rc = msm_rpc_call(snd->ept,
			SND_SET_VOLUME_PROC,
			&vmsg, sizeof(vmsg), 5 * HZ);
		break;

	case SND_AVC_CTL:
		if (get_user(avc, (uint32_t __user *) arg)) {
			rc = -EFAULT;
			break;
		} else if ((avc != 1) && (avc != 0)) {
			rc = -EINVAL;
			break;
		}

		avc_msg.args.avc_ctl = cpu_to_be32(avc);
		avc_msg.args.cb_func = -1;
		avc_msg.args.client_data = 0;

		MM_INFO("snd_avc_ctl %d\n", avc);

		rc = msm_rpc_call(snd->ept,
			SND_AVC_CTL_PROC,
			&avc_msg, sizeof(avc_msg), 5 * HZ);
		break;

	case SND_AGC_CTL:
		if (get_user(agc, (uint32_t __user *) arg)) {
			rc = -EFAULT;
			break;
		} else if ((agc != 1) && (agc != 0)) {
			rc = -EINVAL;
			break;
		}
		agc_msg.args.agc_ctl = cpu_to_be32(agc);
		agc_msg.args.cb_func = -1;
		agc_msg.args.client_data = 0;

		MM_INFO("snd_agc_ctl %d\n", agc);

		rc = msm_rpc_call(snd->ept,
			SND_AGC_CTL_PROC,
			&agc_msg, sizeof(agc_msg), 5 * HZ);
		break;

	case SND_GET_NUM_ENDPOINTS:
		if (copy_to_user((void __user *)arg,
				&snd->snd_epts->num, sizeof(unsigned))) {
			MM_ERR("get endpoint: invalid pointer\n");
			rc = -EFAULT;
		}
		break;

	case SND_GET_ENDPOINT:
		rc = get_endpoint(snd, arg);
		break;

	default:
		MM_ERR("unknown command\n");
		rc = -EINVAL;
		break;
	}
	mutex_unlock(&snd->lock);

	return rc;
}
static void
mddi_novatec_power(struct msm_mddi_client_data *client_data, int on)
{
	unsigned pulldown = 1;

	if (panel_type == 0) {
		if (on) {
			if(axi_clk)
				clk_set_rate(axi_clk, 192000000);

			vreg_enable(vreg_ldo20);
			hr_msleep(5);
			vreg_disable(vreg_ldo20);
			hr_msleep(55);
			gpio_set_value(GLACIER_LCD_2V85_EN, 1);
			/* OJ_2V85*/
			vreg_enable(vreg_ldo12);
			hr_msleep(1);
			vreg_enable(vreg_ldo20);
			hr_msleep(2);
			vreg_enable(vreg_ldo19);
			hr_msleep(2);
			gpio_set_value(GLACIER_MDDI_RSTz, 1);
			hr_msleep(2);
			gpio_set_value(GLACIER_MDDI_RSTz, 0);
			hr_msleep(2);
			gpio_set_value(GLACIER_MDDI_RSTz, 1);
			hr_msleep(65);
		} else {
			hr_msleep(130);
			gpio_set_value(GLACIER_MDDI_RSTz, 0);
			hr_msleep(15);
			vreg_disable(vreg_ldo20);
			hr_msleep(15);
			vreg_disable(vreg_ldo19);
			/* OJ_2V85*/
			vreg_disable(vreg_ldo12);
			gpio_set_value(GLACIER_LCD_2V85_EN, 0);
			msm_proc_comm(PCOM_VREG_PULLDOWN, &pulldown, &vreg_ldo20->id);
			msm_proc_comm(PCOM_VREG_PULLDOWN, &pulldown, &vreg_ldo19->id);
			msm_proc_comm(PCOM_VREG_PULLDOWN, &pulldown, &vreg_ldo12->id);
		}
	} else {
		if (on) {
			if(axi_clk)
				clk_set_rate(axi_clk, 192000000);

			vreg_enable(vreg_ldo20);
			hr_msleep(5);
			vreg_disable(vreg_ldo20);
			hr_msleep(55);
			gpio_set_value(GLACIER_LCD_2V85_EN, 1);
			/* OJ_2V85*/
			vreg_enable(vreg_ldo12);
			hr_msleep(1);
			vreg_enable(vreg_ldo20);
			hr_msleep(2);
			vreg_enable(vreg_ldo19);
			hr_msleep(2);
			gpio_set_value(GLACIER_MDDI_RSTz, 1);
			hr_msleep(2);
			gpio_set_value(GLACIER_MDDI_RSTz, 0);
			hr_msleep(2);
			gpio_set_value(GLACIER_MDDI_RSTz, 1);
			hr_msleep(65);
		} else {
			hr_msleep(130);
			gpio_set_value(GLACIER_MDDI_RSTz, 0);
			hr_msleep(15);
			vreg_disable(vreg_ldo20);
			hr_msleep(15);
			vreg_disable(vreg_ldo19);
			/* OJ_2V85*/
			vreg_disable(vreg_ldo12);
			gpio_set_value(GLACIER_LCD_2V85_EN, 0);
			msm_proc_comm(PCOM_VREG_PULLDOWN, &pulldown, &vreg_ldo20->id);
			msm_proc_comm(PCOM_VREG_PULLDOWN, &pulldown, &vreg_ldo19->id);
			msm_proc_comm(PCOM_VREG_PULLDOWN, &pulldown, &vreg_ldo12->id);
		}
	}
}
Beispiel #21
0
static int clock_disable(unsigned id)
{
	return msm_proc_comm(PCOM_CLKCTL_RPC_DISABLE, &id, 0);
}
static int htcleo_kgsl_power_rail_mode(int follow_clk)
{
	int mode = follow_clk ? 0 : 1;
	int rail_id = 0;
	return msm_proc_comm(PCOM_CLK_REGIME_SEC_RAIL_CONTROL, &rail_id, &mode);
}
Beispiel #23
0
void reboot(unsigned reboot_reason)
{
	msm_proc_comm(PCOM_RESET_CHIP, &reboot_reason, 0);
	for (;;) ;
}
static int touch_cal_ioctl(struct inode *inode, struct file *file, unsigned int cmd,unsigned long arg)
{
	void __user *argp = (void __user *)arg;
	int cal_data[8] = {0,};
	int current_cal_mode = 0;
	int i, idx;

	printk("[touch_cal_ioctl]cmd[%d]\n", cmd); 

	switch (cmd) {
	case TOUCH_CAL_GET_DATA:
		for(i=0 ; i < 8 ; i++)
		{
			idx = i;
			msm_proc_comm(PCOM_OEM_GET_TOUCH_CAL, &cal_data[i], &idx);		
			printk("### get cal_data[%d]:%d\n", i, cal_data[i]); 			
		}
		apply_cal_data(cal_data);
		break;
	case TOUCH_CAL_SET_DATA:

		printk("[touch_cal_ioctl]TOUCH_CAL_SET_DATA\n"); 

		ts_calibration_for_touch_key_region(TOUCH_KEY_FILENAME, cal_data);

		/*
		if (copy_from_user(&cal_data[0], argp, sizeof(cal_data))){
			return -ENODEV;
		}
		*/

		for(i=0 ; i < 8 ; i++)
		{
			idx = i;
			msm_proc_comm(PCOM_OEM_SET_TOUCH_CAL, &cal_data[i], &idx);		
			
			printk("[SWIFT TOUCH CAL](%d) cal_data:%d\n", i, idx); 
		}

#if 1
		apply_cal_data(cal_data);
#else
		if (cal_data[0]) {
			x1 = (cal_data[0] * (X_MAX - X_MIN) / 320) + X_MIN;
		}

		if (cal_data[1]) {
			y1 = ((cal_data[1] + 20) * (Y_MAX - Y_MIN) / 450) + Y_MIN;
		}

		if (cal_data[2]) {
			x2 = (cal_data[2] * (X_MAX - X_MIN) / 320) + X_MIN;
		}

		if (cal_data[3]) {
			y2 = (cal_data[3] * (Y_MAX - Y_MIN) / 450) + Y_MIN;
		}

		if (cal_data[4]) {
			x3 = (cal_data[4] * (X_MAX - X_MIN) / 320) + X_MIN;
		}

		if (cal_data[5]) {
			y3 = (cal_data[5] * (Y_MAX - Y_MIN) / 450) + Y_MIN;
		}

		if (cal_data[6]) {
			x4 = (cal_data[6] * (X_MAX - X_MIN) / 320) + X_MIN;
		}

		if (cal_data[7]) {
			y4 = ((cal_data[7] + 20 )* (Y_MAX - Y_MIN) / 450) + Y_MIN;
		}

		menu_x = x1 - ((x4 - x1) * 100 / 541);
		menu_y = y2 + ((y2 - y1) * 100 / 841); /* 567 */
		back_x = x4 + ((x4 - x1) * 100 / 541);
		back_y = y3 + ((y3 - y4) * 100 / 841); /* 567 */
	
		if (!menu_x || !menu_y || !back_x || !back_y) {
			menu_x = MENU_KEY_X;
			menu_y = TS_KEY_Y; 
			back_x = BACK_KEY_X;
			back_y = TS_KEY_Y; 
		}

		printk("[SWIFT TOUCH CAL] X1:%d, Y1:%d\n", x1, y1);  
		printk("[SWIFT TOUCH CAL] X2:%d, Y2:%d\n", x2, y2);  
		printk("[SWIFT TOUCH CAL] X3:%d, Y3:%d\n", x3, y3);  
		printk("[SWIFT TOUCH CAL] X4:%d, Y4:%d\n", x4, y4);  
		printk("[SWIFT TOUCH CAL] MENU X:%d, MENU Y:%d\n", menu_x, menu_y);  
		printk("[SWIFT TOUCH CAL] BACK X:%d, BACk Y:%d\n", back_x, back_y);  
#endif
		break;
	}

	return 0;
}
Beispiel #25
0
int vreg_set_level(unsigned id, unsigned mv)
{
	return msm_proc_comm(PCOM_VREG_SET_LEVEL, &id, &mv);
}
Beispiel #26
0
static inline int pc_clk_set_max_rate(unsigned id, unsigned rate)
{
	return msm_proc_comm(PCOM_CLKCTL_RPC_MAX_RATE, &id, &rate);
}
Beispiel #27
0
void set_tamper_flag(int tamper)
{
	return msm_proc_comm(PCOM_KERNEL_SEC_BOOT, &tamper, 0);
}
Beispiel #28
0
int vreg_enable(struct vreg *vreg)
{
	unsigned id = vreg->id;
	unsigned enable = 1;
	return msm_proc_comm(PCOM_VREG_SWITCH, &id, &enable);
}