static ssize_t
proximity_data_show(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct input_dev *input_data = to_input_dev(dev);
struct gp2a_data *data = input_get_drvdata(input_data);
int x;
mutex_lock(&data->data_mutex);
x = data->prox_data;
mutex_unlock(&data->data_mutex);
return sprintf(buf, "%d\n", x);
}
static ssize_t bma250_value_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct input_dev *input = to_input_dev(dev);
struct bma250_data *bma250 = input_get_drvdata(input);
struct bma250acc acc_value;
mutex_lock(&bma250->value_mutex);
acc_value = bma250->value;
mutex_unlock(&bma250->value_mutex);
bma_dbg("x=%d, y=%d, z=%d ,%s\n", acc_value.x, acc_value.y, acc_value.z, __FUNCTION__);
return sprintf(buf, "%d %d %d\n", acc_value.x, acc_value.y,
acc_value.z);
}
static ssize_t yas_acc_offset_store(struct device *dev,
struct device_attribute *attr,
const char *buf,
size_t count)
{
struct input_dev *input = to_input_dev(dev);
struct yas_acc_private_data *data = input_get_drvdata(input);
struct yas_vector offset;
sscanf(buf, "%d %d %d", &offset.v[0], &offset.v[1], &offset.v[2]);
yas_acc_set_offset(data->driver, &offset);
return count;
}
static ssize_t mpu6050_input_gyro_self_test_show(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct input_dev *input_data = to_input_dev(dev);
struct mpu6050_input_data *data = input_get_drvdata(input_data);
int scaled_gyro_bias[3] = {0};
int scaled_gyro_rms[3] = {0};
int packet_count[3] = {0};
int result;
mutex_lock(&data->mutex);
result = mpu6050_selftest_run(data->client,
packet_count,
scaled_gyro_bias,
scaled_gyro_rms,
data->gyro_bias);
if (!result) {
gyro_do_calibrate();
} else {
data->gyro_bias[0] = 0;
data->gyro_bias[1] = 0;
data->gyro_bias[2] = 0;
result = -1;
}
mutex_unlock(&data->mutex);
return sprintf(buf, "%d "
"%d %d %d "
"%d.%03d %d.%03d %d.%03d "
"%d.%03d %d.%03d %d.%03d\n",
result,
packet_count[0], packet_count[1], packet_count[2],
(int)abs(scaled_gyro_bias[0]/1000),
(int)abs(scaled_gyro_bias[0])%1000,
(int)abs(scaled_gyro_bias[1]/1000),
(int)abs(scaled_gyro_bias[1])%1000,
(int)abs(scaled_gyro_bias[2]/1000),
(int)abs(scaled_gyro_bias[2])%1000,
scaled_gyro_rms[0]/1000,
(int)abs(scaled_gyro_rms[0])%1000,
scaled_gyro_rms[1]/1000,
(int)abs(scaled_gyro_rms[1])%1000,
scaled_gyro_rms[2]/1000,
(int)abs(scaled_gyro_rms[2])%1000);
}
/* Px data */
static ssize_t px3215_show_adc(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct input_dev *input = to_input_dev(dev);
struct px3215_data *data = input_get_drvdata(input);
static int count; /*count for proximity average */
int adc = 0;
/* No Px data if power down */
if (px3215_get_mode(data->client) == 0x00)
return -EBUSY;
adc = px3215_get_px_value(data->client);
data->average[count] = adc;
if (count == PROX_READ_NUM)
count = 0;
return sprintf(buf, "%d\n", adc);
}
static ssize_t ap3426_store_range(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct input_dev *input = to_input_dev(dev);
struct ap3426_data *data = input_get_drvdata(input);
unsigned long val;
int ret;
if ((strict_strtoul(buf, 10, &val) < 0) || (val > 3))
return -EINVAL;
ret = ap3426_set_range(data->client, val);
return (ret < 0)? ret:count;
}
static ssize_t
geomagnetic_data_show(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct input_dev *input_data = to_input_dev(dev);
struct geomagnetic_data *data = input_get_drvdata(input_data);
int rt;
rt = sprintf(buf, "%d %d %d\n",
atomic_read(&data->last_data[0]),
atomic_read(&data->last_data[1]),
atomic_read(&data->last_data[2]));
return rt;
}
static ssize_t
orientation_status_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct input_dev *input_data = to_input_dev(dev);
unsigned long flags;
int status;
spin_lock_irqsave(&input_data->event_lock, flags);
status = input_abs_get_val(input_data, REL_STATUS);
spin_unlock_irqrestore(&input_data->event_lock, flags);
return sprintf(buf, "%d\n", status);
}
static ssize_t
orientation_enable_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct input_dev *input_data = to_input_dev(dev);
struct orientation_data *data = input_get_drvdata(input_data);
int enabled;
mutex_lock(&data->mutex);
enabled = data->enabled;
mutex_unlock(&data->mutex);
return sprintf(buf, "%d\n", enabled);
}
static ssize_t
light_data_show(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct input_dev *input_data = to_input_dev(dev);
struct sensor_data *data = input_get_drvdata(input_data);
//unsigned long flags;
int light_lux;
mutex_lock(&data->mutex);
light_lux = StateToLux(data->light_data);
mutex_unlock(&data->mutex);
return sprintf(buf, "%d\n", light_lux);
}
static ssize_t
geomagnetic_filter_len_show(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct input_dev *input_data = to_input_dev(dev);
struct geomagnetic_data *data = input_get_drvdata(input_data);
int filter_len;
geomagnetic_multi_lock();
filter_len = data->filter_len;
geomagnetic_multi_unlock();
return sprintf(buf, "%d\n", filter_len);
}
/* Sysfs interface */
static ssize_t
geomagnetic_delay_show(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct input_dev *input_data = to_input_dev(dev);
struct geomagnetic_data *data = input_get_drvdata(input_data);
int delay;
geomagnetic_multi_lock();
delay = data->delay;
geomagnetic_multi_unlock();
return sprintf(buf, "%d\n", delay);
}
static ssize_t al3320_store_mode(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
struct input_dev *input = to_input_dev(dev);
struct al3320_data *data = input_get_drvdata(input);
unsigned long val;
int ret;
if ((strict_strtoul(buf, 10, &val) < 0) || (val > 4))
return -EINVAL;
ret = al3320_set_mode(data->client, val);
if (ret < 0)
return ret;
return count;
}
static ssize_t
geomagnetic_raw_shape_show(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct input_dev *input_raw = to_input_dev(dev);
struct geomagnetic_data *data = input_get_drvdata(input_raw);
int shape;
geomagnetic_multi_lock();
shape = data->shape;
geomagnetic_multi_unlock();
return sprintf(buf, "%d\n", shape);
}
static ssize_t
geomagnetic_raw_manual_offsets_show(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct input_dev *input_raw = to_input_dev(dev);
struct geomagnetic_data *data = input_get_drvdata(input_raw);
struct yas_vector offset;
geomagnetic_multi_lock();
offset = data->manual_offset;
geomagnetic_multi_unlock();
return sprintf(buf, "%d %d %d\n", offset.v[0], offset.v[1], offset.v[2]);
}
static ssize_t
sensor_status_show(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct input_dev *input_data = to_input_dev(dev);
unsigned long flags;
int status;
spin_lock_irqsave(&input_data->event_lock, flags);
status = input_data->absinfo[ABS_STATUS].value;
spin_unlock_irqrestore(&input_data->event_lock, flags);
return sprintf(buf, "%d\n", status);
}
static ssize_t px3215_store_phthres(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
struct input_dev *input = to_input_dev(dev);
struct px3215_data *data = input_get_drvdata(input);
unsigned long val;
int ret;
if (strict_strtoul(buf, 10, &val) < 0)
return -EINVAL;
ret = px3215_set_phthres(data->client, val);
if (ret < 0)
return ret;
return count;
}
static ssize_t
geomagnetic_raw_threshold_show(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct input_dev *input_raw = to_input_dev(dev);
struct geomagnetic_data *data = input_get_drvdata(input_raw);
int threshold;
geomagnetic_multi_lock();
threshold = data->threshold;
geomagnetic_multi_unlock();
return sprintf(buf, "%d\n", threshold);
}
/* Sysfs interface */
static ssize_t
sensor_delay_show(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct input_dev *input_data = to_input_dev(dev);
struct sensor_data *data = input_get_drvdata(input_data);
int delay;
mutex_lock(&data->mutex);
delay = data->delay;
mutex_unlock(&data->mutex);
return sprintf(buf, "%d\n", delay);
}
static ssize_t
orientation_data_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct input_dev *input_data = to_input_dev(dev);
unsigned long flags;
int x, y, z;
spin_lock_irqsave(&input_data->event_lock, flags);
x = input_abs_get_val(input_data, REL_X);
y = input_abs_get_val(input_data, REL_Y);
z = input_abs_get_val(input_data, REL_Z);
spin_unlock_irqrestore(&input_data->event_lock, flags);
return sprintf(buf, "%d %d %d\n", x, y, z);
}
static ssize_t yas_acc_private_data_show(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct input_dev *input = to_input_dev(dev);
struct yas_acc_private_data *data = input_get_drvdata(input);
struct yas_acc_data accel;
#ifdef PANTECH_AVOID_DEADLOCK
accel = data->last;
#else
mutex_lock(&data->data_mutex);
accel = data->last;
mutex_unlock(&data->data_mutex);
#endif
return sprintf(buf, "%d %d %d\n", accel.xyz.v[0], accel.xyz.v[1], accel.xyz.v[2]);
}
static ssize_t yas_acc_debug_suspend_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct input_dev *input = to_input_dev(dev);
struct yas_acc_private_data *data = input_get_drvdata(input);
struct i2c_client *client = data->client;
unsigned long suspend = simple_strtoul(buf, NULL, 10);
if (suspend) {
pm_message_t msg;
yas_acc_suspend(client, msg);
} else {
yas_acc_resume(client);
}
return count;
}
static ssize_t
sensor_report_store(struct device *dev,
struct device_attribute *attr,
const char *buf,
size_t count)
{
struct input_dev *input_data = to_input_dev(dev);
int32_t data_x, data_y, data_z, data_rudder, data_accuracy;
sscanf(buf, "%d %d %d %d %d",
&data_x,
&data_y,
&data_z,
&data_rudder,
&data_accuracy);
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,36)
if( (input_data->abs[ABS_X] != data_x) ||
(input_data->abs[ABS_Y] != data_y) ||
(input_data->abs[ABS_Z] != data_z) )
{
/* Orientation Accuracy Init */
input_data->abs[ABS_STATUS] = 99;
}
#else
if( (input_abs_get_val(input_data, ABS_X) != data_x) ||
(input_abs_get_val(input_data, ABS_Y) != data_y) ||
(input_abs_get_val(input_data, ABS_Z) != data_z) )
{
/* Orientation Accuracy Init */
input_abs_set_val(input_data, ABS_STATUS, 99);
}
#endif
/* report data */
input_report_abs(input_data, ABS_X, data_x);
input_report_abs(input_data, ABS_Y, data_y);
input_report_abs(input_data, ABS_Z, data_z);
// input_report_abs(input_data, ABS_RUDDER, data_rudder);
input_report_abs(input_data, ABS_STATUS, data_accuracy);
input_sync(input_data);
return count;
}
/* lux */
static ssize_t al3320_show_lux(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct input_dev *input = to_input_dev(dev);
struct al3320_data *data = input_get_drvdata(input);
/* No LUX data if power down */
if (al3320_get_mode(data->client) == 0x00){
wake_lock_timeout(&al3320b_wl, 10*HZ);
return sprintf((char*) buf, "%s\n", "Please power up first!");
}
return sprintf(buf, "%d\n", al3320_get_adc_value(data->client,0));
}
static ssize_t bma255_delay_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
int ret;
int64_t delay;
struct input_dev *input = to_input_dev(dev);
struct bma255_p *data = input_get_drvdata(input);
// struct bma255_p *data = bma_acc_get_data();
ret = kstrtoll(buf, 10, &delay);
if (ret) {
pr_err("[SENSOR]: %s - Invalid Argument\n", __func__);
return ret;
}
atomic_set(&data->delay, (unsigned int)delay);
pr_info("[SENSOR]: %s - poll_delay = %lld\n", __func__, delay);
return size;
}
static ssize_t bma023_data_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct input_dev *input = to_input_dev(dev);
struct bma023_data *bma023 = input_get_drvdata(input);
struct acceleration accel;
int on;
mutex_lock(&bma023->data_mutex);
on = bma023_get_enable(dev);
if (!on)
bma023_set_enable(dev, 1);
bma023_measure(bma023, &accel);
if (!on)
bma023_set_enable(dev, 0);
mutex_unlock(&bma023->data_mutex);
return sprintf(buf, "%d,%d,%d\n", accel.x, accel.y, accel.z);
}
static ssize_t light_testmode_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
struct input_dev *input_data = to_input_dev(dev);
struct sensor_data *data = input_get_drvdata(input_data);
int value;
sscanf(buf, "%d", &value);
if(value == 1) {
data->testmode = 1;
gprintk("lightsensor testmode ON.\n");
} else if(value == 0) {
data->testmode = 0;
gprintk("lightsensor testmode OFF.\n");
}
return size;
}
static ssize_t bma255_enable_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size)
{
u8 enable;
int ret;
struct input_dev *input = to_input_dev(dev);
struct bma255_p *data = input_get_drvdata(input);
ret = kstrtou8(buf, 2, &enable);
if (ret) {
pr_err("[SENSOR]: %s - Invalid Argument\n", __func__);
return ret;
}
pr_info("[SENSOR]: %s - new_value = %u\n", __func__, enable);
if ((enable == ON) || (enable == OFF))
bma255_set_enable(data, (int)enable);
return size;
}
/*
* sysfs: wake interface (illumi sensor wake(input))
*/
static ssize_t
sensor_wake_store(struct device *dev,
struct device_attribute *attr,
const char *buf,
size_t count)
{
struct input_dev *input_data = to_input_dev(dev);
static int cnt = 1;
LIGHT_DBG("[LIGHT] sensor_wake_store enter\n");
if(NULL == input_data) {
LIGHT_DBG("[LIGHT] sensor_wake_store null error\n");
return 0;
}
input_report_abs(input_data, ABS_WAKE, cnt++);
return count;
}
static ssize_t yas_acc_enable_store(struct device *dev,
struct device_attribute *attr,
const char *buf,
size_t count)
{
struct input_dev *input = to_input_dev(dev);
struct yas_acc_private_data *data = input_get_drvdata(input);
unsigned long enable = simple_strtoul(buf, NULL, 10);
dbg_func_in();
dbg("%s : enable = %d\n", __func__, (int)enable);
yas_acc_set_enable(data->driver, enable);
dbg_func_out();
return count;
}
