/** * @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; }
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; }
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; }
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; }
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; }
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; }
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, ®); 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, ®); 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; }
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, ®); 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; }
#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");