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;
}
