static int __init sensor_init(void)
{
#include <mach/willow_version.h>
if(g_willow_hw_version!=WILLOW_HW_DVT){
YLOGE("sensor_init : Not use this! yamaha sensor only used DVT device!\n");
return -1;
}
sensor_pdev = platform_device_register_simple(SENSOR_NAME, 0, NULL, 0);
if (IS_ERR(sensor_pdev)) {
return -1;
}
return platform_driver_register(&sensor_driver);
}
static int yas_itg3500_write_reg(unsigned char adr, unsigned char *buf, int len)
{
struct yas_gyro_driver_callback *cbk = &pcb->callback;
struct yas_itg3500_data *p = &itg3500_data;
int err = YAS_NO_ERROR;
int32_t err_cnt = 0;
int32_t reset = 0;
if (p->device_open) {
do {
err = cbk->device_write(adr, buf, len);
if (err != 0 && (++err_cnt >= KC_SENSOR_DEVICE_ERR_MAX)) {
reset = atomic_read(&at_device_reset);
YLOGE(("%s(): [ERR device_write] reset=%d\n",__func__,reset));
if(reset == 0)
atomic_set( &at_device_reset, 1 );
if(reset == 2)
atomic_set( &at_device_reset, 3 );
}
} while(err != 0 && (err_cnt < KC_SENSOR_DEVICE_ERR_MAX));
}
return err;
}
static int sensor_probe(struct platform_device *pdev)
{
struct orient_platform_data *orient_data = NULL;
struct input_dev *input_data = NULL;
int input_registered = 0, sysfs_created = 0;
int rt;
pr_info("[SENSOR] %s: IN\n", __func__);
orient_data = kzalloc(sizeof(struct orient_platform_data), GFP_KERNEL);
if (!orient_data) {
rt = -ENOMEM;
goto err;
}
orient_data->enabled = 0;
orient_data->delay = SENSOR_DEFAULT_DELAY;
input_data = input_allocate_device();
if (!input_data) {
rt = -ENOMEM;
YLOGE(("sensor_probe: Failed to allocate input_data device\n"));
goto err;
}
set_bit(EV_ABS, input_data->evbit);
input_set_abs_params(input_data, ABS_X, INT_MIN, INT_MAX, 0, 0);
#if SENSOR_TYPE <= 4 || (9 <= SENSOR_TYPE && SENSOR_TYPE <= 11)
input_set_abs_params(input_data, ABS_Y, INT_MIN, INT_MAX, 0, 0);
input_set_abs_params(input_data, ABS_Z, INT_MIN, INT_MAX, 0, 0);
#endif
input_set_abs_params(input_data, ABS_RUDDER, INT_MIN, INT_MAX, 0, 0);
input_set_abs_params(input_data, ABS_STATUS, 0, 3, 0, 0);
input_set_abs_params(input_data, ABS_WAKE, INT_MIN, INT_MAX, 0, 0);
input_set_abs_params(input_data, ABS_CONTROL_REPORT, INT_MIN, INT_MAX,
0, 0);
input_data->name = SENSOR_NAME;
rt = input_register_device(input_data);
if (rt) {
YLOGE(("ori Unable to reg input_data %s\n", input_data->name));
goto err;
}
orient_data->orient_input_dev = input_data;
input_set_drvdata(input_data, orient_data);
platform_set_drvdata(pdev, orient_data);
input_registered = 1;
rt = sysfs_create_group(&input_data->dev.kobj, &sensor_attribute_group);
if (rt) {
YLOGE(("sensor_probe: sysfs_create_group failed[%s]\n",
input_data->name));
goto err;
}
sysfs_created = 1;
mutex_init(&(orient_data->mutex));
pr_info("[SENSOR] %s: Success! \n", __func__);
return 0;
err:
if (orient_data != NULL) {
if (input_data != NULL) {
if (sysfs_created)
sysfs_remove_group(&input_data->dev.kobj,
&sensor_attribute_group);
if (input_registered)
input_unregister_device(input_data);
else
input_free_device(input_data);
input_data = NULL;
}
kfree(orient_data);
}
return rt;
}
static void
geomagnetic_input_work_func(struct work_struct *work)
{
struct geomagnetic_data *data = container_of((struct delayed_work *)work,
struct geomagnetic_data, work);
uint32_t time_delay_ms = 100;
struct yas_mag_offset offset;
struct yas_mag_data magdata;
int rt, i, accuracy;
YLOGE(("[HSS] geomagnetic_input_work_func\n"));
if (hwdep_driver.measure == NULL || hwdep_driver.get_offset == NULL) {
return;
}
rt = hwdep_driver.measure(&magdata, &time_delay_ms);
if (rt < 0) {
YLOGE(("measure failed[%d]\n", rt));
}
YLOGE(("xy1y2 [%d][%d][%d] raw[%d][%d][%d]\n",
magdata.xy1y2.v[0], magdata.xy1y2.v[1], magdata.xy1y2.v[2],
magdata.xyz.v[0], magdata.xyz.v[1], magdata.xyz.v[2]));
if (rt >= 0) {
accuracy = atomic_read(&data->last_status);
if ((rt & YAS_REPORT_OVERFLOW_OCCURED)
|| (rt & YAS_REPORT_HARD_OFFSET_CHANGED)
|| (rt & YAS_REPORT_CALIB_OFFSET_CHANGED)) {
static uint16_t count = 1;
int code = 0;
int value = 0;
hwdep_driver.get_offset(&offset);
geomagnetic_multi_lock();
data->driver_offset = offset;
if (rt & YAS_REPORT_OVERFLOW_OCCURED) {
atomic_set(&data->last_status, 0);
accuracy = 0;
}
geomagnetic_multi_unlock();
/* report event */
code |= (rt & YAS_REPORT_OVERFLOW_OCCURED);
code |= (rt & YAS_REPORT_HARD_OFFSET_CHANGED);
code |= (rt & YAS_REPORT_CALIB_OFFSET_CHANGED);
value = (count++ << 16) | (code);
input_report_abs(data->input_raw, ABS_RAW_REPORT, value);
}
if (rt & YAS_REPORT_DATA) {
for (i = 0; i < 3; i++) {
atomic_set(&data->last_data[i], magdata.xyz.v[i]);
}
/* report magnetic data in [nT] */
input_report_abs(data->input_data, ABS_X, magdata.xyz.v[0]);
input_report_abs(data->input_data, ABS_Y, magdata.xyz.v[1]);
input_report_abs(data->input_data, ABS_Z, magdata.xyz.v[2]);
input_report_abs(data->input_data, ABS_STATUS, accuracy);
input_sync(data->input_data);
}
if (rt & YAS_REPORT_CALIB) {
/* report raw magnetic data */
input_report_abs(data->input_raw, ABS_X, magdata.raw.v[0]);
input_report_abs(data->input_raw, ABS_Y, magdata.raw.v[1]);
input_report_abs(data->input_raw, ABS_Z, magdata.raw.v[2]);
input_sync(data->input_raw);
}
}
else {
time_delay_ms = 100;
}
if (time_delay_ms > 0) {
schedule_delayed_work(&data->work, msecs_to_jiffies(time_delay_ms) + 1);
}
else {
schedule_delayed_work(&data->work, 0);
}
}
static int
geomagnetic_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
struct geomagnetic_data *data = NULL;
struct input_dev *input_data = NULL, *input_raw = NULL;
int rt, sysfs_created = 0, sysfs_raw_created = 0;
int data_registered = 0, raw_registered = 0, i;
struct yas_mag_filter filter;
YLOGE(("[HSS] geomagnetic_probe\n"));
i2c_set_clientdata(client, NULL);
data = kzalloc(sizeof(struct geomagnetic_data), GFP_KERNEL);
if (data == NULL) {
rt = -ENOMEM;
goto err;
}
data->threshold = YAS_DEFAULT_MAGCALIB_THRESHOLD;
for (i = 0; i < 3; i++) {
data->distortion[i] = YAS_DEFAULT_MAGCALIB_DISTORTION;
}
data->shape = 0;
atomic_set(&data->enable, 0);
for (i = 0; i < 3; i++) {
atomic_set(&data->last_data[i], 0);
}
atomic_set(&data->last_status, 0);
INIT_DELAYED_WORK(&data->work, geomagnetic_input_work_func);
init_MUTEX(&data->driver_lock);
init_MUTEX(&data->multi_lock);
input_data = input_allocate_device();
if (input_data == NULL) {
rt = -ENOMEM;
YLOGE(("geomagnetic_probe: Failed to allocate input_data device\n"));
goto err;
}
input_data->name = GEOMAGNETIC_INPUT_NAME;
input_data->id.bustype = BUS_I2C;
set_bit(EV_ABS, input_data->evbit);
input_set_capability(input_data, EV_ABS, ABS_X);
input_set_capability(input_data, EV_ABS, ABS_Y);
input_set_capability(input_data, EV_ABS, ABS_Z);
input_set_capability(input_data, EV_ABS, ABS_STATUS);
input_set_capability(input_data, EV_ABS, ABS_WAKE);
input_data->dev.parent = &client->dev;
rt = input_register_device(input_data);
if (rt) {
YLOGE(("geomagnetic_probe: Unable to register input_data device: %s\n",
input_data->name));
goto err;
}
data_registered = 1;
rt = sysfs_create_group(&input_data->dev.kobj,
&geomagnetic_attribute_group);
if (rt) {
YLOGE(("geomagnetic_probe: sysfs_create_group failed[%s]\n",
input_data->name));
goto err;
}
sysfs_created = 1;
input_raw = input_allocate_device();
if (input_raw == NULL) {
rt = -ENOMEM;
YLOGE(("geomagnetic_probe: Failed to allocate input_raw device\n"));
goto err;
}
input_raw->name = GEOMAGNETIC_INPUT_RAW_NAME;
input_raw->id.bustype = BUS_I2C;
set_bit(EV_ABS, input_raw->evbit);
input_set_capability(input_raw, EV_ABS, ABS_X);
input_set_capability(input_raw, EV_ABS, ABS_Y);
input_set_capability(input_raw, EV_ABS, ABS_Z);
input_set_capability(input_raw, EV_ABS, ABS_RAW_DISTORTION);
input_set_capability(input_raw, EV_ABS, ABS_RAW_THRESHOLD);
input_set_capability(input_raw, EV_ABS, ABS_RAW_SHAPE);
input_set_capability(input_raw, EV_ABS, ABS_RAW_REPORT);
input_raw->dev.parent = &client->dev;
rt = input_register_device(input_raw);
if (rt) {
YLOGE(("geomagnetic_probe: Unable to register input_raw device: %s\n",
input_raw->name));
goto err;
}
raw_registered = 1;
rt = sysfs_create_group(&input_raw->dev.kobj,
&geomagnetic_raw_attribute_group);
if (rt) {
YLOGE(("geomagnetic_probe: sysfs_create_group failed[%s]\n",
input_data->name));
goto err;
}
sysfs_raw_created = 1;
this_client = client;
data->input_raw = input_raw;
data->input_data = input_data;
input_set_drvdata(input_data, data);
input_set_drvdata(input_raw, data);
i2c_set_clientdata(client, data);
// [Hss]
gpio_set_value_cansleep(180, 0);
printk(KERN_ERR "Compass I: RST LOW\n");
udelay(120);
gpio_set_value_cansleep(180, 1);
printk(KERN_ERR "Compass I: RST HIGH\n");
if ((rt = yas_mag_driver_init(&hwdep_driver)) < 0) {
YLOGE(("yas_mag_driver_init failed[%d]\n", rt));
goto err;
}
if (hwdep_driver.init != NULL) {
if ((rt = hwdep_driver.init()) < 0) {
YLOGE(("hwdep_driver.init() failed[%d]\n", rt));
goto err;
}
}
if (hwdep_driver.set_position != NULL) {
if (hwdep_driver.set_position(YAS_CDRV_YAS529_POSITION) < 0) {
YLOGE(("hwdep_driver.set_position() failed[%d]\n", rt));
goto err;
}
}
if (hwdep_driver.get_offset != NULL) {
if (hwdep_driver.get_offset(&data->driver_offset) < 0) {
YLOGE(("hwdep_driver get_driver_state failed\n"));
goto err;
}
}
if (hwdep_driver.get_delay != NULL) {
data->delay = hwdep_driver.get_delay();
}
if (hwdep_driver.set_filter_enable != NULL) {
/* default to enable */
if (hwdep_driver.set_filter_enable(1) == 0) {
data->filter_enable = 1;
}
}
if (hwdep_driver.get_filter != NULL) {
if (hwdep_driver.get_filter(&filter) < 0) {
YLOGE(("hwdep_driver get_filter failed\n"));
goto err;
}
data->filter_len = filter.len;
for (i = 0; i < 3; i++) {
data->filter_noise[i] = filter.noise[i];
}
data->filter_threshold = filter.threshold;
}
return 0;
err:
if (data != NULL) {
if (input_raw != NULL) {
if (sysfs_raw_created) {
sysfs_remove_group(&input_raw->dev.kobj,
&geomagnetic_raw_attribute_group);
}
if (raw_registered) {
input_unregister_device(input_raw);
}
else {
input_free_device(input_raw);
}
}
if (input_data != NULL) {
if (sysfs_created) {
sysfs_remove_group(&input_data->dev.kobj,
&geomagnetic_attribute_group);
}
if (data_registered) {
input_unregister_device(input_data);
}
else {
input_free_device(input_data);
}
}
kfree(data);
}
return rt;
}
static int
sensor_probe(struct platform_device *pdev)
{
struct sensor_data *data = NULL;
struct input_dev *input_data = NULL;
int input_registered = 0, sysfs_created = 0;
int rt;
printk(KERN_INFO "%s: %s \n", SENSOR_NAME, __func__);
data = kzalloc(sizeof(struct sensor_data), GFP_KERNEL);
if (!data) {
rt = -ENOMEM;
goto err;
}
data->enabled = 0;
data->delay = SENSOR_DEFAULT_DELAY;
input_data = input_allocate_device();
if (!input_data) {
rt = -ENOMEM;
YLOGE(("sensor_probe: Failed to allocate input_data device\n"));
goto err;
}
set_bit(EV_ABS, input_data->evbit);
input_set_capability(input_data, EV_ABS, ABS_X);
#if SENSOR_TYPE <= 4
input_set_capability(input_data, EV_ABS, ABS_Y);
input_set_capability(input_data, EV_ABS, ABS_Z);
#endif
input_set_capability(input_data, EV_ABS, ABS_STATUS); /* status */
input_set_capability(input_data, EV_ABS, ABS_WAKE); /* wake */
input_set_capability(input_data, EV_ABS, ABS_CONTROL_REPORT); /* enabled/delay */
input_set_abs_params(input_data, ABS_WAKE, 0, 0xffff, 0, 0);
input_data->name = SENSOR_NAME;
rt = input_register_device(input_data);
if (rt) {
YLOGE(("sensor_probe: Unable to register input_data device: %s\n",
input_data->name));
goto err;
}
input_set_drvdata(input_data, data);
input_registered = 1;
rt = sysfs_create_group(&input_data->dev.kobj,
&sensor_attribute_group);
if (rt) {
YLOGE(("sensor_probe: sysfs_create_group failed[%s]\n",
input_data->name));
goto err;
}
sysfs_created = 1;
rt = sysfs_create_link(input_data->dev.kobj.parent,
&input_data->dev.kobj,
input_data->name);
if (rt) {
YLOGE(("sensor_probe: sysfs_create_link failed[%s]\n",
input_data->name));
goto err;
}
mutex_init(&data->mutex);
this_data = input_data;
return 0;
err:
if (data != NULL) {
if (input_data != NULL) {
if (sysfs_created) {
sysfs_remove_group(&input_data->dev.kobj,
&sensor_attribute_group);
}
if (input_registered) {
input_unregister_device(input_data);
}
else {
input_free_device(input_data);
}
input_data = NULL;
}
kfree(data);
}
printk(KERN_ERR "%s: %s err = %d\n", SENSOR_NAME, __func__, rt);
return rt;
}
static int
geomagnetic_work(struct yas_mag_data *magdata)
{
struct geomagnetic_data *data = i2c_get_clientdata(this_client);
uint32_t time_delay_ms = 100;
struct yas_mag_offset offset;
int rt, i, accuracy;
if (hwdep_driver.measure == NULL || hwdep_driver.get_offset == NULL) {
return time_delay_ms;
}
rt = hwdep_driver.measure(magdata, &time_delay_ms);
if (rt < 0) {
YLOGE(("measure failed[%d]\n", rt));
}
YLOGD(("xy1y2 [%d][%d][%d] raw[%d][%d][%d]\n",
magdata->xy1y2.v[0], magdata->xy1y2.v[1], magdata->xy1y2.v[2],
magdata->xyz.v[0], magdata->xyz.v[1], magdata->xyz.v[2]));
if (rt >= 0) {
accuracy = atomic_read(&data->last_status);
if ((rt & YAS_REPORT_OVERFLOW_OCCURED)
|| (rt & YAS_REPORT_HARD_OFFSET_CHANGED)
|| (rt & YAS_REPORT_CALIB_OFFSET_CHANGED)) {
static uint16_t count = 1;
int code = 0;
int value = 0;
hwdep_driver.get_offset(&offset);
geomagnetic_multi_lock();
data->driver_offset = offset;
if (rt & YAS_REPORT_OVERFLOW_OCCURED) {
atomic_set(&data->last_status, 0);
accuracy = 0;
}
geomagnetic_multi_unlock();
/* report event */
code |= (rt & YAS_REPORT_OVERFLOW_OCCURED);
code |= (rt & YAS_REPORT_HARD_OFFSET_CHANGED);
code |= (rt & YAS_REPORT_CALIB_OFFSET_CHANGED);
value = (count++ << 16) | (code);
input_report_abs(data->input_raw, ABS_RAW_REPORT, value);
}
if (rt & YAS_REPORT_DATA) {
for (i = 0; i < 3; i++) {
atomic_set(&data->last_data[i], magdata->xyz.v[i]);
}
/* report magnetic data in [nT] */
input_report_abs(data->input_data, ABS_X, magdata->xyz.v[0]);
input_report_abs(data->input_data, ABS_Y, magdata->xyz.v[1]);
input_report_abs(data->input_data, ABS_Z, magdata->xyz.v[2]);
input_report_abs(data->input_data, ABS_STATUS, accuracy);
input_sync(data->input_data);
}
/* report raw magnetic data */
input_report_abs(data->input_raw, ABS_X, magdata->raw.v[0]);
input_report_abs(data->input_raw, ABS_Y, magdata->raw.v[1]);
input_report_abs(data->input_raw, ABS_Z, magdata->raw.v[2]);
input_sync(data->input_raw);
}
else {
time_delay_ms = 100;
}
return time_delay_ms;
}
static int
sensor_probe(struct platform_device *pdev)
{
struct sensor_data *data = NULL;
struct input_dev *input_data = NULL;
int input_registered = 0, sysfs_created = 0;
int rt;
data = kzalloc(sizeof(struct sensor_data), GFP_KERNEL);
if (!data) {
rt = -ENOMEM;
goto err;
}
data->enabled = 0;
data->delay = SENSOR_DEFAULT_DELAY;
input_data = input_allocate_device();
if (!input_data) {
rt = -ENOMEM;
YLOGE(("sensor_probe: Failed to allocate input_data device\n"));
goto err;
}
set_bit(EV_ABS, input_data->evbit);
input_set_abs_params(input_data, ABS_X, 0x80000000, 0x7fffffff, 0, 0);
#if SENSOR_TYPE <= 4
input_set_abs_params(input_data, ABS_Y, 0x80000000, 0x7fffffff, 0, 0);
input_set_abs_params(input_data, ABS_Z, 0x80000000, 0x7fffffff, 0, 0);
#endif
// input_set_abs_params(input_data, ABS_RUDDER, 0x80000000, 0x7fffffff, 0, 0);
input_set_abs_params(input_data, ABS_STATUS, 0, 3, 0, 0);
input_set_abs_params(input_data, ABS_WAKE, 0x80000000, 0x7fffffff, 0, 0);
input_set_abs_params(input_data, ABS_CONTROL_REPORT, 0x80000000, 0x7fffffff, 0, 0);
input_data->name = SENSOR_NAME;
rt = input_register_device(input_data);
if (rt) {
YLOGE(("sensor_probe: Unable to register input_data device: %s\n",
input_data->name));
goto err;
}
input_set_drvdata(input_data, data);
input_registered = 1;
rt = sysfs_create_group(&input_data->dev.kobj,
&sensor_attribute_group);
if (rt) {
YLOGE(("sensor_probe: sysfs_create_group failed[%s]\n",
input_data->name));
goto err;
}
sysfs_created = 1;
mutex_init(&data->mutex);
this_data = input_data;
return 0;
err:
if (data != NULL) {
if (input_data != NULL) {
if (sysfs_created) {
sysfs_remove_group(&input_data->dev.kobj,
&sensor_attribute_group);
}
if (input_registered) {
input_unregister_device(input_data);
}
else {
input_free_device(input_data);
}
input_data = NULL;
}
kfree(data);
}
return rt;
}
static int
geomagnetic_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
struct geomagnetic_data *data = NULL;
struct input_dev *input_data = NULL, *input_raw = NULL;
int rt, sysfs_created = 0, sysfs_raw_created = 0;
int data_registered = 0, raw_registered = 0, i;
struct yas_mag_filter filter;
i2c_set_clientdata(client, NULL);
data = kzalloc(sizeof(struct geomagnetic_data), GFP_KERNEL);
if (data == NULL) {
rt = -ENOMEM;
goto err;
}
data->threshold = YAS_DEFAULT_MAGCALIB_THRESHOLD;
for (i = 0; i < 3; i++) {
data->distortion[i] = YAS_DEFAULT_MAGCALIB_DISTORTION;
}
data->shape = 0;
atomic_set(&data->enable, 0);
for (i = 0; i < 3; i++) {
atomic_set(&data->last_data[i], 0);
}
atomic_set(&data->last_status, 0);
INIT_DELAYED_WORK(&data->work, geomagnetic_input_work_func);
#ifndef PANTECH_AVOID_DEADLOCK //p12911 : ef33s sensor patch
init_MUTEX(&data->driver_lock);
init_MUTEX(&data->multi_lock);
#endif
input_data = input_allocate_device();
if (input_data == NULL) {
rt = -ENOMEM;
YLOGE(("geomagnetic_probe: Failed to allocate input_data device\n"));
goto err;
}
input_data->name = GEOMAGNETIC_INPUT_NAME;
input_data->id.bustype = BUS_I2C;
set_bit(EV_ABS, input_data->evbit);
//p12911 : ef33s sensor patch
input_set_abs_params(input_data, ABS_X, 0x80000000, 0x7fffffff, 0, 0);
input_set_abs_params(input_data, ABS_Y, 0x80000000, 0x7fffffff, 0, 0);
input_set_abs_params(input_data, ABS_Z, 0x80000000, 0x7fffffff, 0, 0);
input_set_abs_params(input_data, ABS_RUDDER, 0x80000000, 0x7fffffff, 0, 0);
input_set_abs_params(input_data, ABS_STATUS, 0, 3, 0, 0);
input_set_abs_params(input_data, ABS_WAKE, 0x80000000, 0x7fffffff, 0, 0);
//p12911 : ef33s sensor patch
input_data->dev.parent = &client->dev;
rt = input_register_device(input_data);
if (rt) {
YLOGE(("geomagnetic_probe: Unable to register input_data device: %s\n",
input_data->name));
goto err;
}
data_registered = 1;
rt = sysfs_create_group(&input_data->dev.kobj,
&geomagnetic_attribute_group);
if (rt) {
YLOGE(("geomagnetic_probe: sysfs_create_group failed[%s]\n",
input_data->name));
goto err;
}
sysfs_created = 1;
input_raw = input_allocate_device();
if (input_raw == NULL) {
rt = -ENOMEM;
YLOGE(("geomagnetic_probe: Failed to allocate input_raw device\n"));
goto err;
}
input_raw->name = GEOMAGNETIC_INPUT_RAW_NAME;
input_raw->id.bustype = BUS_I2C;
set_bit(EV_ABS, input_raw->evbit);
//p12911 : ef33s sensor patch
input_set_abs_params(input_raw, ABS_X, 0x80000000, 0x7fffffff, 0, 0);
input_set_abs_params(input_raw, ABS_Y, 0x80000000, 0x7fffffff, 0, 0);
input_set_abs_params(input_raw, ABS_Z, 0x80000000, 0x7fffffff, 0, 0);
input_set_abs_params(input_raw, ABS_RAW_DISTORTION, 0, 0x7fffffff, 0, 0);
input_set_abs_params(input_raw, ABS_RAW_THRESHOLD, 0, 2, 0, 0);
input_set_abs_params(input_raw, ABS_RAW_SHAPE, 0, 1, 0, 0);
input_set_abs_params(input_raw, ABS_RAW_REPORT, 0x80000000, 0x7fffffff, 0, 0);
//p12911 : ef33s sensor patch
input_raw->dev.parent = &client->dev;
rt = input_register_device(input_raw);
if (rt) {
YLOGE(("geomagnetic_probe: Unable to register input_raw device: %s\n",
input_raw->name));
goto err;
}
raw_registered = 1;
rt = sysfs_create_group(&input_raw->dev.kobj,
&geomagnetic_raw_attribute_group);
if (rt) {
YLOGE(("geomagnetic_probe: sysfs_create_group failed[%s]\n",
input_data->name));
goto err;
}
sysfs_raw_created = 1;
this_client = client;
data->input_raw = input_raw;
data->input_data = input_data;
input_set_drvdata(input_data, data);
input_set_drvdata(input_raw, data);
i2c_set_clientdata(client, data);
if ((rt = yas_mag_driver_init(&hwdep_driver)) < 0) {
YLOGE(("yas_mag_driver_init failed[%d]\n", rt));
goto err;
}
if (hwdep_driver.init != NULL) {
if ((rt = hwdep_driver.init()) < 0) {
YLOGE(("hwdep_driver.init() failed[%d]\n", rt));
goto err;
}
}
if (hwdep_driver.set_position != NULL) {
if (hwdep_driver.set_position(CONFIG_INPUT_YAS_MAGNETOMETER_POSITION) < 0) {
YLOGE(("hwdep_driver.set_position() failed[%d]\n", rt));
goto err;
}
}
if (hwdep_driver.get_offset != NULL) {
if (hwdep_driver.get_offset(&data->driver_offset) < 0) {
YLOGE(("hwdep_driver get_driver_state failed\n"));
goto err;
}
}
if (hwdep_driver.get_delay != NULL) {
data->delay = hwdep_driver.get_delay();
}
if (hwdep_driver.set_filter_enable != NULL) {
/* default to enable */
if (hwdep_driver.set_filter_enable(1) == 0) {
data->filter_enable = 1;
}
}
if (hwdep_driver.get_filter != NULL) {
if (hwdep_driver.get_filter(&filter) < 0) {
YLOGE(("hwdep_driver get_filter failed\n"));
goto err;
}
data->filter_len = filter.len;
for (i = 0; i < 3; i++) {
data->filter_noise[i] = filter.noise[i];
}
data->filter_threshold = filter.threshold;
}
#ifdef YAS_MAG_TRANSFORM_MATRIX //p12911 : ef33s sensor patch
if (hwdep_driver.get_transform_matrix != NULL) {
hwdep_driver.get_transform_matrix(data->transform_matrix);
}
#endif
return 0;
err:
if (data != NULL) {
if (input_raw != NULL) {
if (sysfs_raw_created) {
sysfs_remove_group(&input_raw->dev.kobj,
&geomagnetic_raw_attribute_group);
}
if (raw_registered) {
input_unregister_device(input_raw);
}
else {
input_free_device(input_raw);
}
}
if (input_data != NULL) {
if (sysfs_created) {
sysfs_remove_group(&input_data->dev.kobj,
&geomagnetic_attribute_group);
}
if (data_registered) {
input_unregister_device(input_data);
}
else {
input_free_device(input_data);
}
}
kfree(data);
}
return rt;
}
