C++ (Cpp) MLOSMalloc 예제들

예제 #1

파일: bma250.c 프로젝트: Amin-jkr/android_kernel_semc_msm8660-1

/**
 *  @brief one-time device driver initialization function.
 *         If the driver is built as a kernel module, this function will be
 *         called when the module is loaded in the kernel.
 *         If the driver is built-in in the kernel, this function will be
 *         called at boot time.
 *
 *  @param mlsl_handle
 *             the handle to the serial channel the device is connected to.
 *  @param slave
 *             a pointer to the slave descriptor data structure.
 *  @param pdata
 *             a pointer to the slave platform data.
 *
 *  @return ML_SUCCESS if successful or a non-zero error code.
 */
static int bma250_init(void *mlsl_handle,
			 struct ext_slave_descr *slave,
			 struct ext_slave_platform_data *pdata)
{
	struct bma250_private_data *private_data;

	if ((!pdata->check_sleep_status && pdata->vote_sleep_status) ||
		(pdata->check_sleep_status && !pdata->vote_sleep_status))
		return ML_ERROR_INVALID_PARAMETER;

	private_data = MLOSMalloc(sizeof(struct bma250_private_data));
	if (!private_data)
		return ML_ERROR_MEMORY_EXAUSTED;

	pdata->private_data = private_data;

	(void)bma250_set_odr(mlsl_handle, pdata, &private_data->suspend,
				FALSE, 0);
	(void)bma250_set_odr(mlsl_handle, pdata, &private_data->resume,
				FALSE, 200000);
	(void)bma250_set_fsr(mlsl_handle, pdata, &private_data->suspend,
				FALSE, 2000L);
	(void)bma250_set_fsr(mlsl_handle, pdata, &private_data->resume,
				FALSE, 2000L);

	return ML_SUCCESS;
}

예제 #2

파일: lis331.c 프로젝트: Aaroneke/galaxy-2636

static int lis331dlh_init(void *mlsl_handle,
			  struct ext_slave_descr *slave,
			  struct ext_slave_platform_data *pdata)
{
	struct lis331dlh_private_data *private_data;
	private_data = (struct lis331dlh_private_data *)
		MLOSMalloc(sizeof(struct lis331dlh_private_data));

	if (!private_data)
		return ML_ERROR_MEMORY_EXAUSTED;

	pdata->private_data = private_data;

	private_data->resume.ctrl_reg1 = 0x37;
	private_data->suspend.ctrl_reg1 = 0x47;

	lis331dlh_set_odr(&private_data->suspend, 50000);
	lis331dlh_set_odr(&private_data->resume, 200000);
	lis331dlh_set_fsr(&private_data->suspend, 2048);
	lis331dlh_set_fsr(&private_data->resume, 2048);
	lis331dlh_set_ths(&private_data->suspend, 80);
	lis331dlh_set_ths(&private_data->resume, 40);
	lis331dlh_set_dur(&private_data->suspend, 1000);
	lis331dlh_set_dur(&private_data->resume,  2540);
	return ML_SUCCESS;
}

예제 #3

파일: lis3dh.c 프로젝트: amuxtux/exynos4210

static int lis3dh_init(void *mlsl_handle,
			  struct ext_slave_descr *slave,
			  struct ext_slave_platform_data *pdata)
{
	tMLError result;

	struct lis3dh_private_data *private_data;
	private_data = (struct lis3dh_private_data *)
		MLOSMalloc(sizeof(struct lis3dh_private_data));

	if (!private_data)
		return ML_ERROR_MEMORY_EXAUSTED;

	pdata->private_data = private_data;

	private_data->resume.ctrl_reg1 = 0x67;
	private_data->suspend.ctrl_reg1 = 0x18;
	private_data->resume.mot_int1_cfg = 0x95;
	private_data->suspend.mot_int1_cfg = 0x2a;

	lis3dh_set_odr(mlsl_handle, pdata, &private_data->suspend,
			FALSE, 0);
	lis3dh_set_odr(mlsl_handle, pdata, &private_data->resume,
			FALSE, 200000);
	lis3dh_set_fsr(mlsl_handle, pdata, &private_data->suspend,
			FALSE, 2048);
	lis3dh_set_fsr(mlsl_handle, pdata, &private_data->resume,
			FALSE, 2048);
	lis3dh_set_ths(mlsl_handle, pdata, &private_data->suspend,
			FALSE, 80);
	lis3dh_set_ths(mlsl_handle, pdata, &private_data->resume,
			FALSE, 40);
	lis3dh_set_dur(mlsl_handle, pdata, &private_data->suspend,
			FALSE, 1000);
	lis3dh_set_dur(mlsl_handle, pdata, &private_data->resume,
			FALSE,  2540);
	lis3dh_set_irq(mlsl_handle, pdata, &private_data->suspend,
			FALSE,
			MPU_SLAVE_IRQ_TYPE_NONE);
	lis3dh_set_irq(mlsl_handle, pdata, &private_data->resume,
			FALSE,
			MPU_SLAVE_IRQ_TYPE_NONE);

	result = MLSLSerialWriteSingle(mlsl_handle, pdata->address,
				       LIS3DH_CTRL_REG1, 0x07);
	MLOSSleep(6);

	return ML_SUCCESS;
}

예제 #4

파일: lis331.c 프로젝트: amuxtux/exynos4210

static int lis331dlh_init(void *mlsl_handle,
			  struct ext_slave_descr *slave,
			  struct ext_slave_platform_data *pdata)
{
	struct lis331dlh_private_data *private_data;
	private_data = (struct lis331dlh_private_data *)
		MLOSMalloc(sizeof(struct lis331dlh_private_data));

	if (!private_data)
		return ML_ERROR_MEMORY_EXAUSTED;

	pdata->private_data = private_data;

	private_data->resume.ctrl_reg1 = 0x37;
	private_data->suspend.ctrl_reg1 = 0x47;
	private_data->resume.mot_int1_cfg = 0x95;
	private_data->suspend.mot_int1_cfg = 0x2a;

	lis331dlh_set_odr(mlsl_handle, pdata, &private_data->suspend,
			FALSE, 0);
	lis331dlh_set_odr(mlsl_handle, pdata, &private_data->resume,
			FALSE, 200000);
	lis331dlh_set_fsr(mlsl_handle, pdata, &private_data->suspend,
			FALSE, 2048);
	lis331dlh_set_fsr(mlsl_handle, pdata, &private_data->resume,
			FALSE, 2048);
	lis331dlh_set_ths(mlsl_handle, pdata, &private_data->suspend,
			FALSE, 80);
	lis331dlh_set_ths(mlsl_handle, pdata, &private_data->resume,
			FALSE, 40);
	lis331dlh_set_dur(mlsl_handle, pdata, &private_data->suspend,
			FALSE, 1000);
	lis331dlh_set_dur(mlsl_handle, pdata, &private_data->resume,
			FALSE,  2540);
	lis331dlh_set_irq(mlsl_handle, pdata, &private_data->suspend,
			FALSE,
			MPU_SLAVE_IRQ_TYPE_NONE);
	lis331dlh_set_irq(mlsl_handle, pdata, &private_data->resume,
			FALSE,
			MPU_SLAVE_IRQ_TYPE_NONE);
	return ML_SUCCESS;
}

예제 #5

파일: mantis.c 프로젝트: amuxtux/exynos4210

static int mantis_init(void *mlsl_handle,
		       struct ext_slave_descr *slave,
		       struct ext_slave_platform_data *pdata)
{
	struct mantis_private_data *private_data;
	private_data = (struct mantis_private_data *)
		MLOSMalloc(sizeof(struct mantis_private_data));

	if (!private_data)
		return ML_ERROR_MEMORY_EXAUSTED;

	pdata->private_data = private_data;

	mantis_set_odr(&private_data->suspend, 0);
	mantis_set_odr(&private_data->resume, 200000);
	mantis_set_fsr(&private_data->suspend, 2000);
	mantis_set_fsr(&private_data->resume, 2000);
	mantis_set_ths(&private_data->suspend, 80);
	mantis_set_ths(&private_data->resume, 40);
	mantis_set_dur(&private_data->suspend, 1000);
	mantis_set_dur(&private_data->resume,  2540);
	return ML_SUCCESS;
}

예제 #6

static int kxtf9_init(void *mlsl_handle,
		struct ext_slave_descr *slave,
		struct ext_slave_platform_data *pdata)
{

	struct kxtf9_private_data *private_data;
	int result = ML_SUCCESS;

	private_data = (struct kxtf9_private_data *)
		MLOSMalloc(sizeof(struct kxtf9_private_data));

	if (!private_data)
		return ML_ERROR_MEMORY_EXAUSTED;

	/* RAM reset */
	result = MLSLSerialWriteSingle(mlsl_handle, pdata->address,
				KXTF9_CTRL_REG1,
				0x40); /* Fastest Reset */
	ERROR_CHECK(result);
	result = MLSLSerialWriteSingle(mlsl_handle, pdata->address,
				KXTF9_DATA_CTRL_REG,
				0x36); /* Fastest Reset */
	ERROR_CHECK(result);
	result = MLSLSerialWriteSingle(mlsl_handle, pdata->address,
				KXTF9_CTRL_REG3, 0xcd); /* Reset */
	ERROR_CHECK(result);
	MLOSSleep(2);

	pdata->private_data = private_data;

	private_data->resume.ctrl_reg1 = 0xC0;
	private_data->suspend.ctrl_reg1 = 0x40;

	result = kxtf9_set_dur(mlsl_handle, pdata, &private_data->suspend,
			FALSE, 1000);
	ERROR_CHECK(result);
	result = kxtf9_set_dur(mlsl_handle, pdata, &private_data->resume,
			FALSE,  2540);
	ERROR_CHECK(result);

	result = kxtf9_set_odr(mlsl_handle, pdata, &private_data->suspend,
			FALSE, 50000);
	ERROR_CHECK(result);
	result = kxtf9_set_odr(mlsl_handle, pdata, &private_data->resume,
			FALSE, 200000);

	result = kxtf9_set_fsr(mlsl_handle, pdata, &private_data->suspend,
			FALSE, 2000);
	ERROR_CHECK(result);
	result = kxtf9_set_fsr(mlsl_handle, pdata, &private_data->resume,
			FALSE, 2000);
	ERROR_CHECK(result);

	result = kxtf9_set_ths(mlsl_handle, pdata, &private_data->suspend,
			FALSE, 80);
	ERROR_CHECK(result);
	result = kxtf9_set_ths(mlsl_handle, pdata, &private_data->resume,
			FALSE, 40);
	ERROR_CHECK(result);

	result = kxtf9_set_irq(mlsl_handle, pdata, &private_data->suspend,
			FALSE,
			MPU_SLAVE_IRQ_TYPE_NONE);
	ERROR_CHECK(result);
	result = kxtf9_set_irq(mlsl_handle, pdata, &private_data->resume,
			FALSE,
			MPU_SLAVE_IRQ_TYPE_NONE);
	ERROR_CHECK(result);
	return result;
}

예제 #7

파일: bma250.c 프로젝트: AmeriCanAndroid/aca-evo3d-omega-htc-35

static int bma250_init(void *mlsl_handle,
			  struct ext_slave_descr *slave,
			  struct ext_slave_platform_data *pdata)
{
	tMLError result;
	unsigned char reg = 0;
	unsigned char bw_reg = 0;

	struct bma250_private_data *private_data;
	private_data = (struct bma250_private_data *)
		MLOSMalloc(sizeof(struct bma250_private_data));

	if (!private_data)
		return ML_ERROR_MEMORY_EXAUSTED;



	pdata->private_data = private_data;

	result =
	    MLSLSerialWriteSingle(mlsl_handle, pdata->address,
		BMA250_REG_SOFT_RESET, 0xB6);  /* BMA250: Software reset */
	ERROR_CHECK(result);
	MLOSSleep(1);

	result =
	    MLSLSerialRead(mlsl_handle, pdata->address, BOSCH_CTRL_REG, 1,
				&reg);
	ERROR_CHECK(result);

	result =
	    MLSLSerialRead(mlsl_handle, pdata->address, BMA250_BW_REG, 1,
				&bw_reg);
	ERROR_CHECK(result);

	private_data->resume.ctrl_reg = reg;
	private_data->suspend.ctrl_reg = reg;

	private_data->resume.bw_reg = bw_reg;
	private_data->suspend.bw_reg = bw_reg;

	/* TODO Use irq when necessary */
	/*result =
	    MLSLSerialRead(mlsl_handle, pdata->address, BOSCH_INT_REG, 1, &reg);
	ERROR_CHECK(result);*/

	private_data->resume.int_reg = reg;
	private_data->suspend.int_reg = reg;

	private_data->resume.power_mode = 1;
	private_data->suspend.power_mode = 0;

	private_data->state = 0;

	bma250_set_odr(mlsl_handle, pdata, &private_data->suspend,
			FALSE, 0);
	bma250_set_odr(mlsl_handle, pdata, &private_data->resume,
			FALSE, 25000);
	bma250_set_fsr(mlsl_handle, pdata, &private_data->suspend,
			FALSE, 2048);
	bma250_set_fsr(mlsl_handle, pdata, &private_data->resume,
			FALSE, 2048);

	/* TODO Use irq when necessary */
	/*bma250_set_irq(mlsl_handle, pdata, &private_data->suspend,
			FALSE,
			MPU_SLAVE_IRQ_TYPE_NONE);
	bma250_set_irq(mlsl_handle, pdata, &private_data->resume,
			FALSE,
			MPU_SLAVE_IRQ_TYPE_NONE);*/

	result =
	    MLSLSerialWriteSingle(mlsl_handle, pdata->address, BOSCH_PWR_REG,
					0x80);
	ERROR_CHECK(result);

	return result;
}

예제 #8

파일: bma250.c 프로젝트: Albinoman887/pyramid-3.4.10

static int bma250_init(void *mlsl_handle,
			  struct ext_slave_descr *slave,
			  struct ext_slave_platform_data *pdata)
{
	tMLError result;
	unsigned char reg = 0;
	unsigned char bw_reg = 0;

	struct bma250_private_data *private_data;
	private_data = (struct bma250_private_data *)
		MLOSMalloc(sizeof(struct bma250_private_data));

	printk(KERN_DEBUG "%s\n", __func__);

	if (!private_data)
		return ML_ERROR_MEMORY_EXAUSTED;



	pdata->private_data = private_data;

	result =
	    MLSLSerialWriteSingle(mlsl_handle, pdata->address,
		BMA250_REG_SOFT_RESET, 0xB6);  
	ERROR_CHECK(result);
	MLOSSleep(1);

	result =
	    MLSLSerialRead(mlsl_handle, pdata->address, BOSCH_CTRL_REG, 1,
				&reg);
	ERROR_CHECK(result);

	result =
	    MLSLSerialRead(mlsl_handle, pdata->address, BMA250_BW_REG, 1,
				&bw_reg);
	ERROR_CHECK(result);

	private_data->resume.ctrl_reg = reg;
	private_data->suspend.ctrl_reg = reg;

	private_data->resume.bw_reg = bw_reg;
	private_data->suspend.bw_reg = bw_reg;

	

	private_data->resume.int_reg = reg;
	private_data->suspend.int_reg = reg;

	private_data->resume.power_mode = 1;
	private_data->suspend.power_mode = 0;

	private_data->state = 0;

	bma250_set_odr(mlsl_handle, pdata, &private_data->suspend,
			FALSE, 0);
	bma250_set_odr(mlsl_handle, pdata, &private_data->resume,
			TRUE, 25000);
	bma250_set_fsr(mlsl_handle, pdata, &private_data->suspend,
			FALSE, 2048);
	bma250_set_fsr(mlsl_handle, pdata, &private_data->resume,
			FALSE, 2048);

	

	result =
	    MLSLSerialWriteSingle(mlsl_handle, pdata->address, BOSCH_PWR_REG,
					0x80);
	ERROR_CHECK(result);

	return result;
}

예제 #9

#else
			  struct ext_slave_platform_data *pdata
			  )
#endif
{
	tMLError result = 0;
	unsigned char reg = 0;
	unsigned char bw_reg = 0;
#ifdef CONFIG_CIR_ALWAYS_READY
	struct class *bma250_class = NULL;
	struct device *bma250_dev = NULL;
	int res;
#endif
	struct bma250_private_data *private_data;
	private_data = (struct bma250_private_data *)
		MLOSMalloc(sizeof(struct bma250_private_data));

	printk(KERN_DEBUG "%s\n", __func__);

	if (!private_data)
		return ML_ERROR_MEMORY_EXAUSTED;


#ifdef CONFIG_CIR_ALWAYS_READY

	g_pdata = pdata;
	gsensor_power_LPM = power_LPM;
	g_mlsl_handle = mlsl_handle;

	bma250_class = class_create(THIS_MODULE, "bma250");