static int __init ami304_init(void) { int ret; if (AMI304_DEBUG_FUNC_TRACE & ami304_debug_mask) AMID("AMI304 MI sensor driver: init\n"); rwlock_init(&ami304mid_data.ctrllock); rwlock_init(&ami304mid_data.datalock); rwlock_init(&ami304_data.lock); memset(&ami304mid_data.controldata[0], 0, sizeof(int)*10); ami304mid_data.controldata[0] = 200*1000; //Loop Delay ami304mid_data.controldata[1] = 0; // Run ami304mid_data.controldata[2] = 0; // Disable Start-AccCali ami304mid_data.controldata[3] = 1; // Enable Start-Cali ami304mid_data.controldata[4] = 350; // MW-Timout ami304mid_data.controldata[5] = 10; // MW-IIRStrength_M ami304mid_data.controldata[6] = 10; // MW-IIRStrength_G atomic_set(&dev_open_count, 0); atomic_set(&hal_open_count, 0); atomic_set(&daemon_open_count, 0); ret = i2c_add_driver(&ami304_i2c_driver); if (ret) { AMIE("failed to probe i2c \n"); i2c_del_driver(&ami304_i2c_driver); } return ret; }
static int AMI304_Init(int mode) { u8 databuf[10]; u8 regaddr; u8 ctrl1, ctrl2, ctrl3; int res = 0; regaddr = AMI304_REG_CTRL1; res = i2c_master_send(ami304_i2c_client, ®addr, 1); if (res<=0) goto exit_AMI304_Init; res = i2c_master_recv(ami304_i2c_client, &ctrl1, 1); if (res<=0) goto exit_AMI304_Init; regaddr = AMI304_REG_CTRL2; res = i2c_master_send(ami304_i2c_client, ®addr, 1); if (res<=0) goto exit_AMI304_Init; res = i2c_master_recv(ami304_i2c_client, &ctrl2, 1); if (res<=0) goto exit_AMI304_Init; regaddr = AMI304_REG_CTRL3; res = i2c_master_send(ami304_i2c_client, ®addr, 1); if (res<=0) goto exit_AMI304_Init; res = i2c_master_recv(ami304_i2c_client, &ctrl3, 1); if (res<=0) goto exit_AMI304_Init; databuf[0] = AMI304_REG_CTRL1; if( mode==AMI304_FORCE_MODE ) { databuf[1] = ctrl1 | AMI304_CTRL1_PC1 | AMI304_CTRL1_FS1_FORCE; write_lock(&ami304_data.lock); ami304_data.mode = AMI304_FORCE_MODE; write_unlock(&ami304_data.lock); } else { databuf[1] = ctrl1 | AMI304_CTRL1_PC1 | AMI304_CTRL1_FS1_NORMAL | AMI304_CTRL1_ODR1; write_lock(&ami304_data.lock); ami304_data.mode = AMI304_NORMAL_MODE; write_unlock(&ami304_data.lock); } res = i2c_master_send(ami304_i2c_client, databuf, 2); if (res<=0) goto exit_AMI304_Init; databuf[0] = AMI304_REG_CTRL2; databuf[1] = ctrl2 | AMI304_CTRL2_DREN; res = i2c_master_send(ami304_i2c_client, databuf, 2); if (res<=0) goto exit_AMI304_Init; databuf[0] = AMI304_REG_CTRL3; databuf[1] = ctrl3 | AMI304_CTRL3_B0_LO_CLR; res = i2c_master_send(ami304_i2c_client, databuf, 2); if (res<=0) goto exit_AMI304_Init; exit_AMI304_Init: if (res<=0) { AMIE("I2C error: ret value=%d\n", res); return -3; } return 0; }
static int AMI304_ReadSensorData(char *buf, int bufsize) { char cmd; int mode = 0; unsigned char databuf[10] = {0,}; int res = 0; if ((!buf)||(bufsize<=80)) return -1; if (!ami304_i2c_client) { *buf = 0; return -2; } read_lock(&ami304_data.lock); mode = ami304_data.mode; read_unlock(&ami304_data.lock); databuf[0] = AMI304_REG_CTRL3; databuf[1] = AMI304_CTRL3_FORCE_BIT; res = i2c_master_send(ami304_i2c_client, databuf, 2); if (res<=0) goto exit_AMI304_ReadSensorData; // We can read all measured data in once cmd = AMI304_REG_DATAXH; res = i2c_master_send(ami304_i2c_client, &cmd, 1); if (res<=0) goto exit_AMI304_ReadSensorData; res = i2c_master_recv(ami304_i2c_client, &(databuf[0]), 6); if (res<=0) goto exit_AMI304_ReadSensorData; sprintf(buf, "%02x %02x %02x %02x %02x %02x", databuf[0], databuf[1], databuf[2], databuf[3], databuf[4], databuf[5]); if (AMI304_DEBUG_DEV_STATUS & ami304_debug_mask) { int mx, my, mz; mx = my = mz = 0; mx = (int)(databuf[0] | (databuf[1] << 8)); my = (int)(databuf[2] | (databuf[3] << 8)); mz = (int)(databuf[4] | (databuf[5] << 8)); if (mx>32768) mx = mx-65536; if (my>32768) my = my-65536; if (mz>32768) mz = mz-65536; //AMID("X=%d, Y=%d, Z=%d\n", (int)(databuf[0] | (databuf[1] << 8)), (int)(databuf[2] | (databuf[3] << 8)), (int)(databuf[4] | (databuf[5] << 8))); AMID("X=%d, Y=%d, Z=%d\n", mx, my, mz); } exit_AMI304_ReadSensorData: if (res<=0) { if(printk_ratelimit()) AMIE("I2C error: ret value=%d\n", res); return -3; } return 0; }
static int __init ami306_init(void) { int res; if (AMI306_DEBUG_FUNC_TRACE & ami306_debug_mask) AMID("AMI306 MI sensor driver: init\n"); rwlock_init(&ami306mid_data.ctrllock); rwlock_init(&ami306mid_data.datalock); rwlock_init(&ami306_data.lock); memset(&ami306mid_data.controldata[0], 0, sizeof(int)*10); /* LGE_CHANGE * 200ms is too slow to calibrate, so set 100ms */ /* LGE_CHANGE * 20 ms by sprint request */ ami306mid_data.controldata[AMI306_CB_LOOPDELAY] = 20; // Loop Delay ami306mid_data.controldata[AMI306_CB_RUN] = 1; // Run ami306mid_data.controldata[AMI306_CB_ACCCALI] = 0; // Start-AccCali ami306mid_data.controldata[AMI306_CB_MAGCALI] = 1; // Start-MagCali ami306mid_data.controldata[AMI306_CB_ACTIVESENSORS] = 0; // Active Sensors ami306mid_data.controldata[AMI306_CB_PD_RESET] = 0; // Pedometer not reset ami306mid_data.controldata[AMI306_CB_PD_EN_PARAM] = 0; // Disable parameters of Pedometer ami306mid_data.controldata[AMI306_CB_QWERTY] = 0; // Qwerty Keyboard : close -> 0, open -> 1. ami306mid_data.controldata[AMI306_CB_CHANGE_WINDOW] = 0; //ADC_WINDOW_CONTROL: ADC_WINDOW_NORMAL->0 ADC_WINDOW_CHANGED->1 ADC_WINDOW_EXCEEDED->2 memset(&ami306mid_data.pedometerparam[0], 0, sizeof(int)*AMI306_PD_LENGTH); atomic_set(&dev_open_count, 0); atomic_set(&hal_open_count, 0); atomic_set(&daemon_open_count, 0); res = i2c_add_driver(&ami306_i2c_driver); printk(KERN_INFO "[jaekyung83.lee]ami init\n"); if (res) { AMIE("failed to probe i2c \n"); i2c_del_driver(&ami306_i2c_driver); } return res; }
static int __init ami304_probe(struct i2c_client *client, const struct i2c_device_id * devid) { int err = 0; struct ami304_i2c_data *data; struct ecom_platform_data* ecom_pdata; if (AMI304_DEBUG_FUNC_TRACE & ami304_debug_mask) AMID("motion start....!\n"); if(!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { AMIE("adapter can NOT support I2C_FUNC_I2C.\n"); return -ENODEV; } if (!(data = kmalloc(sizeof(struct ami304_i2c_data), GFP_KERNEL))) { err = -ENOMEM; goto exit; } memset(data, 0, sizeof(struct ami304_i2c_data)); i2c_set_clientdata(client, data); ami304_i2c_client = client; ecom_pdata = ami304_i2c_client->dev.platform_data; ecom_pdata->power(1); AMI304_Init(AMI304_FORCE_MODE); // default is Force State atomic_set(&o_status, 0); atomic_set(&m_status, 0); atomic_set(&a_status, 0); #if defined(CONFIG_HAS_EARLYSUSPEND) ami304_sensor_early_suspend.suspend = ami304_early_suspend; ami304_sensor_early_suspend.resume = ami304_late_resume; register_early_suspend(&ami304_sensor_early_suspend); atomic_set(&ami304_report_enabled, 1); #endif data->input_dev = input_allocate_device(); if (!data->input_dev) { err = -ENOMEM; AMIE("ami304_i2c_detect: Failed to allocate input device\n"); goto exit_input_dev_alloc_failed; } set_bit(EV_ABS, data->input_dev->evbit); /* yaw */ input_set_abs_params(data->input_dev, ABS_RX, 0, 360, 0, 0); /* pitch */ input_set_abs_params(data->input_dev, ABS_RY, -180, 180, 0, 0); /* roll */ input_set_abs_params(data->input_dev, ABS_RZ, -90, 90, 0, 0); /* status of magnetic sensor */ input_set_abs_params(data->input_dev, ABS_RUDDER, 0, 5, 0, 0); /* x-axis acceleration */ input_set_abs_params(data->input_dev, ABS_X, -2000, 2000, 0, 0); /* y-axis acceleration */ input_set_abs_params(data->input_dev, ABS_Y, -2000, 2000, 0, 0); /* z-axis acceleration */ input_set_abs_params(data->input_dev, ABS_Z, -2000, 2000, 0, 0); /* x-axis of raw magnetic vector */ input_set_abs_params(data->input_dev, ABS_HAT0X, -3000, 3000, 0, 0); /* y-axis of raw magnetic vector */ input_set_abs_params(data->input_dev, ABS_HAT0Y, -3000, 3000, 0, 0); /* z-axis of raw magnetic vector */ input_set_abs_params(data->input_dev, ABS_BRAKE, -3000, 3000, 0, 0); /* status of acceleration sensor */ input_set_abs_params(data->input_dev, ABS_WHEEL, 0, 5, 0, 0); data->input_dev->name = "Acompass"; err = input_register_device(data->input_dev); if (err) { AMIE("ami304_i2c_detect: Unable to register input device: %s\n", data->input_dev->name); goto exit_input_register_device_failed; } if (AMI304_DEBUG_FUNC_TRACE & ami304_debug_mask) AMID("register input device successfully!!!\n"); err = misc_register(&ami304_device); if (err) { AMIE("ami304_device register failed\n"); goto exit_misc_device_register_failed; } err = device_create_file(&client->dev, &dev_attr_chipinfo); err = device_create_file(&client->dev, &dev_attr_sensordata); err = device_create_file(&client->dev, &dev_attr_posturedata); err = device_create_file(&client->dev, &dev_attr_calidata); err = device_create_file(&client->dev, &dev_attr_midcontrol); err = device_create_file(&client->dev, &dev_attr_mode); /* Test mode attribute */ err = device_create_file(&client->dev, &dev_attr_pitch); err = device_create_file(&client->dev, &dev_attr_roll); err = misc_register(&ami304daemon_device); if (err) { AMIE("ami304daemon_device register failed\n"); goto exit_misc_device_register_failed; } err = misc_register(&ami304hal_device); if (err) { AMIE("ami304hal_device register failed\n"); goto exit_misc_device_register_failed; } return 0; exit_misc_device_register_failed: exit_input_register_device_failed: input_free_device(data->input_dev); exit_input_dev_alloc_failed: kfree(data); exit: return err; }
static int ami304hal_ioctl(struct inode *inode, struct file *file, unsigned int cmd,unsigned long arg) { char strbuf[AMI304_BUFSIZE]; void __user *data; int retval=0; unsigned int mode =0; int controlbuf[10]; switch (cmd) { case AMI304HAL_IOCTL_GET_SENSORDATA: data = (void __user *) arg; if (data == NULL) break; AMI304_ReadSensorData(strbuf, AMI304_BUFSIZE); if (copy_to_user(data, strbuf, strlen(strbuf)+1)) { retval = -EFAULT; goto err_out; } break; case AMI304HAL_IOCTL_GET_POSTURE: data = (void __user *) arg; if (data == NULL) break; AMI304_ReadPostureData(strbuf, AMI304_BUFSIZE); if (copy_to_user(data, strbuf, strlen(strbuf)+1)) { retval = -EFAULT; goto err_out; } break; case AMI304HAL_IOCTL_GET_CALIDATA: data = (void __user *) arg; if (data == NULL) break; AMI304_ReadCaliData(strbuf, AMI304_BUFSIZE); if (copy_to_user(data, strbuf, strlen(strbuf)+1)) { retval = -EFAULT; goto err_out; } break; case AMI304HAL_IOCTL_SET_ACTIVE: data = (void __user *) arg; if (data == NULL) break; if (copy_from_user(&mode, data, sizeof(mode))) { retval = -EFAULT; goto err_out; } if (AMI304_DEBUG_GEN_INFO & ami304_debug_mask) AMID("ami304hal active sensor %d\n", mode); if(mode & (0x00000001<<AMI_ORIENTATION_SENSOR)) atomic_set(&o_status, 1); else atomic_set(&o_status, 0); if(mode & (0x00000001<<AMI_MAGNETIC_FIELD_SENSOR)) atomic_set(&m_status, 1); else atomic_set(&m_status, 0); if(mode & (0x00000001<<AMI_ACCELEROMETER_SENSOR)) atomic_set(&a_status, 1); else atomic_set(&a_status, 0); break; case AMI304HAL_IOCTL_GET_CONTROL: read_lock(&ami304mid_data.ctrllock); memcpy(controlbuf, &ami304mid_data.controldata[0], sizeof(controlbuf)); read_unlock(&ami304mid_data.ctrllock); data = (void __user *) arg; if (data == NULL) break; if (copy_to_user(data, controlbuf, sizeof(controlbuf))) { retval = -EFAULT; goto err_out; } break; case AMI304HAL_IOCTL_SET_CONTROL: data = (void __user *) arg; if (data == NULL) break; if (copy_from_user(controlbuf, data, sizeof(controlbuf))) { retval = -EFAULT; goto err_out; } write_lock(&ami304mid_data.ctrllock); memcpy(&ami304mid_data.controldata[0], controlbuf, sizeof(controlbuf)); write_unlock(&ami304mid_data.ctrllock); if (AMI304_DEBUG_DELAY_SETTING & ami304_debug_mask) AMID("Dleay setting = %dms\n", ami304mid_data.controldata[0] / 1000); break; default: if (AMI304_DEBUG_USER_ERROR & ami304_debug_mask) AMIE("not supported command= 0x%04x\n", cmd); retval = -ENOIOCTLCMD; break; } err_out: return retval; }
static int ami304daemon_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg) { int valuebuf[4]; int calidata[7]; int controlbuf[10]; char strbuf[AMI304_BUFSIZE]; void __user *data; int retval=0; int mode; #if !defined(CONFIG_HAS_EARLYSUSPEND) int en_dis_Report=1; #endif //LGE_CHANGE_S, [[email protected]], 2010-12-31, <Block Root Authorization Check> //check the authority is root or not // if(!capable(CAP_SYS_ADMIN)) { // retval = -EPERM; // goto err_out; // } //LGE_CHANGE_E, [[email protected]], 2010-12-31, <Block Root Authorization Check> switch (cmd) { case AMI304MID_IOCTL_GET_SENSORDATA: data = (void __user *) arg; if (data == NULL) break; AMI304_ReadSensorData(strbuf, AMI304_BUFSIZE); if (copy_to_user(data, strbuf, strlen(strbuf)+1)) { retval = -EFAULT; goto err_out; } break; case AMI304MID_IOCTL_SET_POSTURE: data = (void __user *) arg; if (data == NULL) break; if (copy_from_user(&valuebuf, data, sizeof(valuebuf))) { retval = -EFAULT; goto err_out; } write_lock(&ami304mid_data.datalock); ami304mid_data.yaw = valuebuf[0]; ami304mid_data.pitch = valuebuf[1]; ami304mid_data.roll = valuebuf[2]; ami304mid_data.mag_status = valuebuf[3]; write_unlock(&ami304mid_data.datalock); break; case AMI304MID_IOCTL_SET_CALIDATA: data = (void __user *) arg; if (data == NULL) break; if (copy_from_user(&calidata, data, sizeof(calidata))) { retval = -EFAULT; goto err_out; } write_lock(&ami304mid_data.datalock); ami304mid_data.nmx = calidata[0]; ami304mid_data.nmy = calidata[1]; ami304mid_data.nmz = calidata[2]; ami304mid_data.nax = calidata[3]; ami304mid_data.nay = calidata[4]; ami304mid_data.naz = calidata[5]; ami304mid_data.mag_status = calidata[6]; write_unlock(&ami304mid_data.datalock); #if defined(CONFIG_HAS_EARLYSUSPEND) /* Disable input report at early suspend state On-Demand Governor set max cpu frequency when input evnet is appeared */ AMI304_Report_Value( atomic_read(&ami304_report_enabled)); #else AMI304_Report_Value(en_dis_Report); #endif break; case AMI304MID_IOCTL_GET_CONTROL: read_lock(&ami304mid_data.ctrllock); memcpy(controlbuf, &ami304mid_data.controldata[0], sizeof(controlbuf)); read_unlock(&ami304mid_data.ctrllock); data = (void __user *) arg; if (data == NULL) break; if (copy_to_user(data, controlbuf, sizeof(controlbuf))) { retval = -EFAULT; goto err_out; } break; case AMI304MID_IOCTL_SET_CONTROL: data = (void __user *) arg; if (data == NULL) break; if (copy_from_user(controlbuf, data, sizeof(controlbuf))) { retval = -EFAULT; goto err_out; } write_lock(&ami304mid_data.ctrllock); memcpy(&ami304mid_data.controldata[0], controlbuf, sizeof(controlbuf)); write_unlock(&ami304mid_data.ctrllock); break; case AMI304MID_IOCTL_SET_MODE: data = (void __user *) arg; if (data == NULL) break; if (copy_from_user(&mode, data, sizeof(mode))) { retval = -EFAULT; goto err_out; } AMI304_SetMode(mode); break; default: if (AMI304_DEBUG_USER_ERROR & ami304_debug_mask) AMIE("not supported command= 0x%04x\n", cmd); retval = -ENOIOCTLCMD; break; } err_out: return retval; }
static int ami304_ioctl(struct inode *inode, struct file *file, unsigned int cmd,unsigned long arg) { char strbuf[AMI304_BUFSIZE]; int controlbuf[10]; void __user *data; int retval=0; int mode=0; //LGE_CHANGE_S, [[email protected]], 2010-12-31, <Block Root Authorization Check> //check the authority is root or not // if(!capable(CAP_SYS_ADMIN)) { // retval = -EPERM; // goto err_out; // } //LGE_CHANGE_E, [[email protected]], 2010-12-31, <Block Root Authorization Check> switch (cmd) { case AMI304_IOCTL_INIT: read_lock(&ami304_data.lock); mode = ami304_data.mode; read_unlock(&ami304_data.lock); AMI304_Init(mode); break; case AMI304_IOCTL_READ_CHIPINFO: data = (void __user *) arg; if (data == NULL) break; AMI304_ReadChipInfo(strbuf, AMI304_BUFSIZE); if (copy_to_user(data, strbuf, strlen(strbuf)+1)) { retval = -EFAULT; goto err_out; } break; case AMI304_IOCTL_READ_SENSORDATA: data = (void __user *) arg; if (data == NULL) break; AMI304_ReadSensorData(strbuf, AMI304_BUFSIZE); if (copy_to_user(data, strbuf, strlen(strbuf)+1)) { retval = -EFAULT; goto err_out; } break; case AMI304_IOCTL_READ_POSTUREDATA: data = (void __user *) arg; if (data == NULL) break; AMI304_ReadPostureData(strbuf, AMI304_BUFSIZE); if (copy_to_user(data, strbuf, strlen(strbuf)+1)) { retval = -EFAULT; goto err_out; } break; case AMI304_IOCTL_READ_CALIDATA: data = (void __user *) arg; if (data == NULL) break; AMI304_ReadCaliData(strbuf, AMI304_BUFSIZE); if (copy_to_user(data, strbuf, strlen(strbuf)+1)) { retval = -EFAULT; goto err_out; } break; case AMI304_IOCTL_READ_CONTROL: read_lock(&ami304mid_data.ctrllock); memcpy(controlbuf, &ami304mid_data.controldata[0], sizeof(controlbuf)); read_unlock(&ami304mid_data.ctrllock); data = (void __user *) arg; if (data == NULL) break; if (copy_to_user(data, controlbuf, sizeof(controlbuf))) { retval = -EFAULT; goto err_out; } break; case AMI304_IOCTL_SET_CONTROL: data = (void __user *) arg; if (data == NULL) break; if (copy_from_user(controlbuf, data, sizeof(controlbuf))) { retval = -EFAULT; goto err_out; } write_lock(&ami304mid_data.ctrllock); memcpy(&ami304mid_data.controldata[0], controlbuf, sizeof(controlbuf)); write_unlock(&ami304mid_data.ctrllock); break; case AMI304_IOCTL_SET_MODE: data = (void __user *) arg; if (data == NULL) break; if (copy_from_user(&mode, data, sizeof(mode))) { retval = -EFAULT; goto err_out; } AMI304_SetMode(mode); break; default: if (AMI304_DEBUG_USER_ERROR & ami304_debug_mask) AMIE("not supported command= 0x%04x\n", cmd); retval = -ENOIOCTLCMD; break; } err_out: return retval; }
static int ami304daemon_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg) { int valuebuf[4]; int calidata[7]; int gyrodata[3]; long pedodata[3]; int controlbuf[AMI304_CB_LENGTH]; char strbuf[AMI304_BUFSIZE]; int pedoparam[AMI304_PD_LENGTH]; char i2creaddata[3]; void __user *data; int retval=0; int mode; #if !defined(CONFIG_HAS_EARLYSUSPEND) int iEnReport; #endif switch (cmd) { case AMI304DAE_IOCTL_GET_SENSORDATA: data = (void __user *) arg; if (data == NULL) break; AMI304_ReadSensorData(strbuf, AMI304_BUFSIZE); if (copy_to_user(data, strbuf, strlen(strbuf)+1)) { retval = -EFAULT; goto err_out; } break; case AMI304DAE_IOCTL_SET_POSTURE: data = (void __user *) arg; if (data == NULL) break; if (copy_from_user(&valuebuf, data, sizeof(valuebuf))) { retval = -EFAULT; goto err_out; } write_lock(&ami304mid_data.datalock); ami304mid_data.yaw = valuebuf[0]; ami304mid_data.pitch = valuebuf[1]; ami304mid_data.roll = valuebuf[2]; ami304mid_data.status = valuebuf[3]; write_unlock(&ami304mid_data.datalock); break; case AMI304DAE_IOCTL_SET_CALIDATA: data = (void __user *) arg; if (data == NULL) break; if (copy_from_user(&calidata, data, sizeof(calidata))) { retval = -EFAULT; goto err_out; } write_lock(&ami304mid_data.datalock); ami304mid_data.nm.x = calidata[0]; ami304mid_data.nm.y = calidata[1]; ami304mid_data.nm.z = calidata[2]; ami304mid_data.na.x = calidata[3]; ami304mid_data.na.y = calidata[4]; ami304mid_data.na.z = calidata[5]; ami304mid_data.status = calidata[6]; write_unlock(&ami304mid_data.datalock); #if defined(CONFIG_HAS_EARLYSUSPEND) /* * Disable input report at early suspend state * On-Demand Governor set max cpu frequency when input event is appeared */ AMI304_Report_Value(atomic_read(&ami304_report_enabled)); #endif break; case AMI304DAE_IOCTL_SET_GYRODATA: data = (void __user *) arg; if (data == NULL) break; if (copy_from_user(&gyrodata, data, sizeof(gyrodata))) { retval = -EFAULT; goto err_out; } write_lock(&ami304mid_data.datalock); ami304mid_data.gyro.x = gyrodata[0]; ami304mid_data.gyro.y = gyrodata[1]; ami304mid_data.gyro.z = gyrodata[2]; write_unlock(&ami304mid_data.datalock); break; case AMI304DAE_IOCTL_SET_PEDODATA: data = (void __user *) arg; if (data == NULL) break; if (copy_from_user(&pedodata, data, sizeof(pedodata))) { retval = -EFAULT; goto err_out; } write_lock(&ami304mid_data.datalock); ami304mid_data.pedo.pedo_step = pedodata[0]; ami304mid_data.pedo.pedo_time = pedodata[1]; ami304mid_data.pedo.pedo_stat = (int)pedodata[2]; write_unlock(&ami304mid_data.datalock); break; case AMI304DAE_IOCTL_GET_PEDOPARAM: read_lock(&ami304mid_data.ctrllock); memcpy(pedoparam, &ami304mid_data.pedometerparam[0], sizeof(pedoparam)); read_unlock(&ami304mid_data.ctrllock); data = (void __user *) arg; if (data == NULL) break; if (copy_to_user(data, pedoparam, sizeof(pedoparam))) { retval = -EFAULT; goto err_out; } break; case AMI304DAE_IOCTL_SET_PEDOPARAM: data = (void __user *) arg; if (data == NULL) break; if (copy_from_user(pedoparam, data, sizeof(pedoparam))) { retval = -EFAULT; goto err_out; } write_lock(&ami304mid_data.ctrllock); memcpy(&ami304mid_data.pedometerparam[0], pedoparam, sizeof(pedoparam)); write_unlock(&ami304mid_data.ctrllock); break; case AMI304DAE_IOCTL_GET_CONTROL: read_lock(&ami304mid_data.ctrllock); memcpy(controlbuf, &ami304mid_data.controldata[0], sizeof(controlbuf)); read_unlock(&ami304mid_data.ctrllock); data = (void __user *) arg; if (data == NULL) break; if (copy_to_user(data, controlbuf, sizeof(controlbuf))) { retval = -EFAULT; goto err_out; } break; case AMI304DAE_IOCTL_SET_CONTROL: data = (void __user *) arg; if (data == NULL) break; if (copy_from_user(controlbuf, data, sizeof(controlbuf))) { retval = -EFAULT; goto err_out; } write_lock(&ami304mid_data.ctrllock); memcpy(&ami304mid_data.controldata[0], controlbuf, sizeof(controlbuf)); write_unlock(&ami304mid_data.ctrllock); break; case AMI304DAE_IOCTL_SET_MODE: data = (void __user *) arg; if (data == NULL) break; if (copy_from_user(&mode, data, sizeof(mode))) { retval = -EFAULT; goto err_out; } AMI304_SetMode(mode); break; //Add for input_device sync case AMI304DAE_IOCTL_SET_REPORT: #if defined(CONFIG_HAS_EARLYSUSPEND) break; #else data = (void __user *) arg; if (data == NULL) break; if (copy_from_user(&iEnReport, data, sizeof(iEnReport))) { retval = -EFAULT; goto err_out; } AMI304_Report_Value(iEnReport); #endif break; case AMI304DAE_IOCTL_GET_WIA: data = (void __user *) arg; if (data == NULL) break; AMI304_WIA(strbuf, AMI304_BUFSIZE); if (copy_to_user(data, strbuf, strlen(strbuf)+1)) { retval = -EFAULT; goto err_out; } break; case AMI304DAE_IOCTL_SET_I2CDATA: data = (void __user *)arg; if (data == NULL) break; if (copy_from_user(strbuf, data, sizeof(strbuf))) { retval = -EFAULT; goto err_out; } AMI304_I2c_Write(strbuf[0], &strbuf[2], strbuf[1]); break; case AMI304DAE_IOCTL_SET_I2CADDR: data = (void __user *)arg; if (data == NULL) break; if (copy_from_user(i2creaddata, data, 2)) { retval = -EFAULT; goto err_out; } i2c_read_addr = i2creaddata[0]; i2c_read_len = i2creaddata[1]; break; case AMI304DAE_IOCTL_GET_I2CDATA: AMI304_I2c_Read(i2c_read_addr, &strbuf[0], i2c_read_len); data = (void __user *)arg; if (data == NULL) break; if (copy_to_user(data, strbuf, i2c_read_len)) { retval = -EFAULT; goto err_out; } break; default: if (AMI304_DEBUG_USER_ERROR & ami304_debug_mask) AMIE("not supported command= 0x%04x\n", cmd); retval = -ENOIOCTLCMD; break; } err_out: return retval; }
static int ami304_ioctl(struct inode *inode, struct file *file, unsigned int cmd,unsigned long arg) { char strbuf[AMI304_BUFSIZE]; int controlbuf[AMI304_CB_LENGTH]; int valuebuf[4]; int calidata[7]; int gyrodata[3]; long pedodata[3]; int pedoparam[AMI304_PD_LENGTH]; void __user *data; int retval=0; int mode=0,chipset=0; int iEnReport; switch (cmd) { case AMI304_IOCTL_INIT: read_lock(&ami304_data.lock); mode = ami304_data.mode; chipset = ami304_data.chipset; read_unlock(&ami304_data.lock); AMI304_Chipset_Init(mode, chipset); break; case AMI304_IOCTL_READ_CHIPINFO: data = (void __user *) arg; if (data == NULL) break; AMI304_ReadChipInfo(strbuf, AMI304_BUFSIZE); if (copy_to_user(data, strbuf, strlen(strbuf)+1)) { retval = -EFAULT; goto err_out; } break; case AMI304_IOCTL_READ_SENSORDATA: data = (void __user *) arg; if (data == NULL) break; AMI304_ReadSensorData(strbuf, AMI304_BUFSIZE); if (copy_to_user(data, strbuf, strlen(strbuf)+1)) { retval = -EFAULT; goto err_out; } break; case AMI304_IOCTL_READ_POSTUREDATA: data = (void __user *) arg; if (data == NULL) break; AMI304_ReadPostureData(strbuf, AMI304_BUFSIZE); if (copy_to_user(data, strbuf, strlen(strbuf)+1)) { retval = -EFAULT; goto err_out; } break; case AMI304_IOCTL_WRITE_POSTUREDATA: data = (void __user *) arg; if (data == NULL) break; if (copy_from_user(&valuebuf, data, sizeof(valuebuf))) { retval = -EFAULT; goto err_out; } write_lock(&ami304mid_data.datalock); ami304mid_data.yaw = valuebuf[0]; ami304mid_data.pitch = valuebuf[1]; ami304mid_data.roll = valuebuf[2]; ami304mid_data.status = valuebuf[3]; write_unlock(&ami304mid_data.datalock); break; case AMI304_IOCTL_READ_CALIDATA: data = (void __user *) arg; if (data == NULL) break; AMI304_ReadCaliData(strbuf, AMI304_BUFSIZE); if (copy_to_user(data, strbuf, strlen(strbuf)+1)) { retval = -EFAULT; goto err_out; } break; case AMI304_IOCTL_WRITE_CALIDATA: data = (void __user *) arg; if (data == NULL) break; if (copy_from_user(&calidata, data, sizeof(calidata))) { retval = -EFAULT; goto err_out; } write_lock(&ami304mid_data.datalock); ami304mid_data.nm.x = calidata[0]; ami304mid_data.nm.y = calidata[1]; ami304mid_data.nm.z = calidata[2]; ami304mid_data.na.x = calidata[3]; ami304mid_data.na.y = calidata[4]; ami304mid_data.na.z = calidata[5]; ami304mid_data.status = calidata[6]; write_unlock(&ami304mid_data.datalock); break; case AMI304_IOCTL_READ_GYRODATA: data = (void __user *) arg; if (data == NULL) break; AMI304_ReadGyroData(strbuf, AMI304_BUFSIZE); if (copy_to_user(data, strbuf, strlen(strbuf)+1)) { retval = -EFAULT; goto err_out; } break; case AMI304_IOCTL_WRITE_GYRODATA: data = (void __user *) arg; if (data == NULL) break; if (copy_from_user(&gyrodata, data, sizeof(gyrodata))) { retval = -EFAULT; goto err_out; } write_lock(&ami304mid_data.datalock); ami304mid_data.gyro.x = gyrodata[0]; ami304mid_data.gyro.y = gyrodata[1]; ami304mid_data.gyro.z = gyrodata[2]; write_unlock(&ami304mid_data.datalock); break; case AMI304_IOCTL_READ_PEDODATA: data = (void __user *) arg; if (data == NULL) break; AMI304_ReadPedoData(strbuf, AMI304_BUFSIZE); if (copy_to_user(data, strbuf, strlen(strbuf)+1)) { retval = -EFAULT; goto err_out; } break; case AMI304_IOCTL_WRITE_PEDODATA: data = (void __user *) arg; if (data == NULL) break; if (copy_from_user(&pedodata, data, sizeof(pedodata))) { retval = -EFAULT; goto err_out; } write_lock(&ami304mid_data.datalock); ami304mid_data.pedo.pedo_step = pedodata[0]; ami304mid_data.pedo.pedo_time = pedodata[1]; ami304mid_data.pedo.pedo_stat = (int)pedodata[2]; write_unlock(&ami304mid_data.datalock); break; case AMI304_IOCTL_READ_PEDOPARAM: read_lock(&ami304mid_data.ctrllock); memcpy(pedoparam, &ami304mid_data.pedometerparam[0], sizeof(pedoparam)); read_unlock(&ami304mid_data.ctrllock); data = (void __user *) arg; if (data == NULL) break; if (copy_to_user(data, pedoparam, sizeof(pedoparam))) { retval = -EFAULT; goto err_out; } break; case AMI304_IOCTL_WRITE_PEDOPARAM: data = (void __user *) arg; if (data == NULL) break; if (copy_from_user(pedoparam, data, sizeof(pedoparam))) { retval = -EFAULT; goto err_out; } write_lock(&ami304mid_data.ctrllock); memcpy(&ami304mid_data.pedometerparam[0], pedoparam, sizeof(pedoparam)); write_unlock(&ami304mid_data.ctrllock); break; case AMI304_IOCTL_READ_CONTROL: read_lock(&ami304mid_data.ctrllock); memcpy(controlbuf, &ami304mid_data.controldata[0], sizeof(controlbuf)); read_unlock(&ami304mid_data.ctrllock); data = (void __user *) arg; if (data == NULL) break; if (copy_to_user(data, controlbuf, sizeof(controlbuf))) { retval = -EFAULT; goto err_out; } break; case AMI304_IOCTL_WRITE_CONTROL: data = (void __user *) arg; if (data == NULL) break; if (copy_from_user(controlbuf, data, sizeof(controlbuf))) { retval = -EFAULT; goto err_out; } write_lock(&ami304mid_data.ctrllock); memcpy(&ami304mid_data.controldata[0], controlbuf, sizeof(controlbuf)); write_unlock(&ami304mid_data.ctrllock); break; case AMI304_IOCTL_WRITE_MODE: data = (void __user *) arg; if (data == NULL) break; if (copy_from_user(&mode, data, sizeof(mode))) { retval = -EFAULT; goto err_out; } AMI304_SetMode(mode); break; case AMI304_IOCTL_WRITE_REPORT: data = (void __user *) arg; if (data == NULL) break; if (copy_from_user(&iEnReport, data, sizeof(iEnReport))) { retval = -EFAULT; goto err_out; } AMI304_Report_Value(iEnReport); break; case AMI304_IOCTL_READ_WIA: data = (void __user *) arg; if (data == NULL) break; AMI304_WIA(strbuf, AMI304_BUFSIZE); if (copy_to_user(data, strbuf, strlen(strbuf)+1)) { retval = -EFAULT; goto err_out; } break; default: if (AMI304_DEBUG_USER_ERROR & ami304_debug_mask) AMIE("not supported command= 0x%04x\n", cmd); retval = -ENOIOCTLCMD; break; } err_out: return retval; }
static int __devinit ami304_probe(struct i2c_client *client, const struct i2c_device_id * devid) { int err = 0; struct ami304_i2c_data *data; struct ecom_platform_data* ecom_pdata; if (AMI304_DEBUG_FUNC_TRACE & ami304_debug_mask) AMID("motion start....!\n"); if(!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { AMIE("adapter can NOT support I2C_FUNC_I2C.\n"); return -ENODEV; } if (!(data = kmalloc(sizeof(struct ami304_i2c_data), GFP_KERNEL))) { err = -ENOMEM; goto exit; } memset(data, 0, sizeof(struct ami304_i2c_data)); data->client = client; i2c_set_clientdata(client, data); ami304_i2c_client = client; ecom_pdata = ami304_i2c_client->dev.platform_data; ecom_pdata->power(1); #if defined(CONFIG_HAS_EARLYSUSPEND) ami304_sensor_early_suspend.suspend = ami304_early_suspend; ami304_sensor_early_suspend.resume = ami304_late_resume; register_early_suspend(&ami304_sensor_early_suspend); atomic_set(&ami304_report_enabled, 1); #endif err=Identify_AMI_Chipset(); if (err != 0) { //get ami304_data.chipset printk(KERN_INFO "Failed to identify AMI_Chipset!\n"); goto exit_kfree; } AMI304_Chipset_Init(AMI304_FORCE_MODE, ami304_data.chipset); // default is Force State dev_info(&client->dev, "%s operating mode\n", ami304_data.mode? "force" : "normal"); printk(KERN_INFO "Register input device!\n"); err = ami304_input_init(data); if(err) goto exit_kfree; //register misc device:ami304 err = misc_register(&ami304_device); if (err) { AMIE("ami304_device register failed\n"); goto exit_misc_ami304_device_register_failed; } //register misc device:ami304daemon err = misc_register(&ami304daemon_device); if (err) { AMIE("ami304daemon_device register failed\n"); goto exit_misc_ami304daemon_device_register_failed; } //register misc device:ami304hal err = misc_register(&ami304hal_device); if (err) { AMIE("ami304hal_device register failed\n"); goto exit_misc_ami304hal_device_register_failed; } /* Register sysfs hooks */ err = sysfs_create_group(&client->dev.kobj, &ami304_attribute_group); if (err) { AMIE("ami304 sysfs register failed\n"); goto exit_sysfs_create_group_failed; } return 0; exit_sysfs_create_group_failed: sysfs_remove_group(&client->dev.kobj, &ami304_attribute_group); exit_misc_ami304hal_device_register_failed: misc_deregister(&ami304daemon_device); exit_misc_ami304daemon_device_register_failed: misc_deregister(&ami304_device); exit_misc_ami304_device_register_failed: input_unregister_device(data->input_dev); input_free_device(data->input_dev); exit_kfree: kfree(data); exit: return err; }
static int ami304_input_init(struct ami304_i2c_data *data) { int err=0; data->input_dev = input_allocate_device(); if (!data->input_dev) { err = -ENOMEM; AMIE("ami304_i2c_detect: Failed to allocate input device\n"); goto exit_input_dev_alloc_failed; } set_bit(EV_ABS, data->input_dev->evbit); /* yaw */ input_set_abs_params(data->input_dev, ABS_RX, 0, (360*10), 0, 0); /* pitch */ input_set_abs_params(data->input_dev, ABS_RY, -(180*10), (180*10), 0, 0); /* roll */ input_set_abs_params(data->input_dev, ABS_RZ, -(90*10), (90*10), 0, 0); /* status of orientation sensor */ input_set_abs_params(data->input_dev, ABS_RUDDER, 0, 5, 0, 0); /* x-axis of raw acceleration and the range is -2g to +2g */ input_set_abs_params(data->input_dev, ABS_X, -(1000*2), (1000*2), 0, 0); /* y-axis of raw acceleration and the range is -2g to +2g */ input_set_abs_params(data->input_dev, ABS_Y, -(1000*2), (1000*2), 0, 0); /* z-axis of raw acceleration and the range is -2g to +2g */ input_set_abs_params(data->input_dev, ABS_Z, -(1000*2), (1000*2), 0, 0); /* x-axis of raw magnetic vector and the range is -3g to +3g */ input_set_abs_params(data->input_dev, ABS_HAT0X, -(4000*3), (4000*3), 0, 0); /* y-axis of raw magnetic vector and the range is -3g to +3g */ input_set_abs_params(data->input_dev, ABS_HAT0Y, -(4000*3), (4000*3), 0, 0); /* z-axis of raw magnetic vector and the range is -3g to +3g */ input_set_abs_params(data->input_dev, ABS_BRAKE, -(4000*3), (4000*3), 0, 0); /* status of magnetic sensor */ input_set_abs_params(data->input_dev, ABS_WHEEL, 0, 5, 0, 0); /* x-axis of gyro sensor */ input_set_abs_params(data->input_dev, ABS_HAT1X, -10000, 10000, 0, 0); /* y-axis of gyro sensor */ input_set_abs_params(data->input_dev, ABS_HAT1Y, -10000, 10000, 0, 0); /* z-axis of gyro sensor */ input_set_abs_params(data->input_dev, ABS_THROTTLE, -10000, 10000, 0, 0); data->input_dev->name = "Acompass"; err = input_register_device(data->input_dev); if (err) { AMIE("ami304_i2c_detect: Unable to register input device: %s\n", data->input_dev->name); goto exit_input_register_device_failed; } if (AMI304_DEBUG_FUNC_TRACE & ami304_debug_mask) AMID("register input device successfully!!!\n"); return 0; exit_input_register_device_failed: input_free_device(data->input_dev); exit_input_dev_alloc_failed: return err; }
static int ami304hal_ioctl(struct inode *inode, struct file *file, unsigned int cmd,unsigned long arg) { int controlbuf[AMI304_CB_LENGTH]; char strbuf[AMI304_BUFSIZE]; int pedoparam[AMI304_PD_LENGTH]; void __user *data; int retval=0; switch (cmd) { case AMI304HAL_IOCTL_GET_SENSORDATA: data = (void __user *) arg; if (data == NULL) break; AMI304_ReadSensorData(strbuf, AMI304_BUFSIZE); if (copy_to_user(data, strbuf, strlen(strbuf)+1)) { retval = -EFAULT; goto err_out; } break; case AMI304HAL_IOCTL_GET_POSTURE: data = (void __user *) arg; if (data == NULL) break; AMI304_ReadPostureData(strbuf, AMI304_BUFSIZE); if (copy_to_user(data, strbuf, strlen(strbuf)+1)) { retval = -EFAULT; goto err_out; } break; case AMI304HAL_IOCTL_GET_CALIDATA: data = (void __user *) arg; if (data == NULL) break; AMI304_ReadCaliData(strbuf, AMI304_BUFSIZE); if (copy_to_user(data, strbuf, strlen(strbuf)+1)) { retval = -EFAULT; goto err_out; } break; case AMI304HAL_IOCTL_GET_GYRODATA: data = (void __user *) arg; if (data == NULL) break; AMI304_ReadGyroData(strbuf, AMI304_BUFSIZE); if (copy_to_user(data, strbuf, strlen(strbuf)+1)) { retval = -EFAULT; goto err_out; } break; case AMI304HAL_IOCTL_GET_PEDODATA: data = (void __user *) arg; if (data == NULL) break; AMI304_ReadPedoData(strbuf, AMI304_BUFSIZE); if (copy_to_user(data, strbuf, strlen(strbuf)+1)) { retval = -EFAULT; goto err_out; } break; case AMI304HAL_IOCTL_GET_PEDOPARAM: read_lock(&ami304mid_data.ctrllock); memcpy(pedoparam, &ami304mid_data.pedometerparam[0], sizeof(pedoparam)); read_unlock(&ami304mid_data.ctrllock); data = (void __user *) arg; if (data == NULL) break; if (copy_to_user(data, pedoparam, sizeof(pedoparam))) { retval = -EFAULT; goto err_out; } break; case AMI304HAL_IOCTL_SET_PEDOPARAM: data = (void __user *) arg; if (data == NULL) break; if (copy_from_user(pedoparam, data, sizeof(pedoparam))) { retval = -EFAULT; goto err_out; } write_lock(&ami304mid_data.ctrllock); memcpy(&ami304mid_data.pedometerparam[0], pedoparam, sizeof(pedoparam)); write_unlock(&ami304mid_data.ctrllock); break; case AMI304HAL_IOCTL_GET_CONTROL: read_lock(&ami304mid_data.ctrllock); memcpy(controlbuf, &ami304mid_data.controldata[0], sizeof(controlbuf)); read_unlock(&ami304mid_data.ctrllock); data = (void __user *) arg; if (data == NULL) break; if (copy_to_user(data, controlbuf, sizeof(controlbuf))) { retval = -EFAULT; goto err_out; } break; case AMI304HAL_IOCTL_SET_CONTROL: data = (void __user *) arg; if (data == NULL) break; if (copy_from_user(controlbuf, data, sizeof(controlbuf))) { retval = -EFAULT; goto err_out; } write_lock(&ami304mid_data.ctrllock); memcpy(&ami304mid_data.controldata[0], controlbuf, sizeof(controlbuf)); write_unlock(&ami304mid_data.ctrllock); break; case AMI304HAL_IOCTL_GET_WIA: data = (void __user *) arg; if (data == NULL) break; AMI304_WIA(strbuf, AMI304_BUFSIZE); if (copy_to_user(data, strbuf, strlen(strbuf)+1)) { retval = -EFAULT; goto err_out; } break; default: if (AMI304_DEBUG_USER_ERROR & ami304_debug_mask) AMIE("not supported command= 0x%04x\n", cmd); retval = -ENOIOCTLCMD; break; } err_out: return retval; }
static int ami304_ioctl(struct inode *inode, struct file *file, unsigned int cmd,unsigned long arg) { char strbuf[AMI304_BUFSIZE]; int controlbuf[10]; void __user *data; int retval=0; int mode=0; switch (cmd) { case AMI304_IOCTL_INIT: read_lock(&ami304_data.lock); mode = ami304_data.mode; read_unlock(&ami304_data.lock); AMI304_Init(mode); break; case AMI304_IOCTL_READ_CHIPINFO: data = (void __user *) arg; if (data == NULL) break; AMI304_ReadChipInfo(strbuf, AMI304_BUFSIZE); if (copy_to_user(data, strbuf, strlen(strbuf)+1)) { retval = -EFAULT; goto err_out; } break; case AMI304_IOCTL_READ_SENSORDATA: data = (void __user *) arg; if (data == NULL) break; AMI304_ReadSensorData(strbuf, AMI304_BUFSIZE); if (copy_to_user(data, strbuf, strlen(strbuf)+1)) { retval = -EFAULT; goto err_out; } break; case AMI304_IOCTL_READ_POSTUREDATA: data = (void __user *) arg; if (data == NULL) break; AMI304_ReadPostureData(strbuf, AMI304_BUFSIZE); if (copy_to_user(data, strbuf, strlen(strbuf)+1)) { retval = -EFAULT; goto err_out; } break; case AMI304_IOCTL_READ_CALIDATA: data = (void __user *) arg; if (data == NULL) break; AMI304_ReadCaliData(strbuf, AMI304_BUFSIZE); if (copy_to_user(data, strbuf, strlen(strbuf)+1)) { retval = -EFAULT; goto err_out; } break; case AMI304_IOCTL_READ_CONTROL: read_lock(&ami304mid_data.ctrllock); memcpy(controlbuf, &ami304mid_data.controldata[0], sizeof(controlbuf)); read_unlock(&ami304mid_data.ctrllock); data = (void __user *) arg; if (data == NULL) break; if (copy_to_user(data, controlbuf, sizeof(controlbuf))) { retval = -EFAULT; goto err_out; } break; case AMI304_IOCTL_SET_CONTROL: data = (void __user *) arg; if (data == NULL) break; if (copy_from_user(controlbuf, data, sizeof(controlbuf))) { retval = -EFAULT; goto err_out; } write_lock(&ami304mid_data.ctrllock); memcpy(&ami304mid_data.controldata[0], controlbuf, sizeof(controlbuf)); write_unlock(&ami304mid_data.ctrllock); break; case AMI304_IOCTL_SET_MODE: data = (void __user *) arg; if (data == NULL) break; if (copy_from_user(&mode, data, sizeof(mode))) { retval = -EFAULT; goto err_out; } AMI304_SetMode(mode); break; default: if (AMI304_DEBUG_USER_ERROR & ami304_debug_mask) AMIE("not supported command= 0x%04x\n", cmd); retval = -ENOIOCTLCMD; break; } err_out: return retval; }