static int ap3426_register_psensor_device(struct i2c_client *client, struct ap3426_data *data)
{
struct input_dev *input_dev;
int rc;
LDBG("allocating input device psensor\n");
input_dev = input_allocate_device();
if (!input_dev) {
dev_err(&client->dev,"%s: could not allocate input device for psensor\n", __FUNCTION__);
rc = -ENOMEM;
goto done;
}
data->psensor_input_dev = input_dev;
input_set_drvdata(input_dev, data);
input_dev->name = "proximity";
input_dev->dev.parent = &client->dev;
set_bit(EV_ABS, input_dev->evbit);
input_set_abs_params(input_dev, ABS_DISTANCE, 0, 1, 0, 0);
rc = input_register_device(input_dev);
if (rc < 0) {
pr_err("%s: could not register input device for psensor\n", __FUNCTION__);
goto done;
}
rc = sysfs_create_group(&input_dev->dev.kobj, &ap3426_ps_attribute_group);// every devices register his own devices
done:
return rc;
}
/*********************************************************************
heartbeat sensor register & unregister
********************************************************************/
static int ap3426_register_heartbeat_sensor_device(struct i2c_client *client, struct ap3426_data *data)
{
struct input_dev *input_dev;
int rc;
LDBG("allocating input device heartbeat sensor\n");
input_dev = input_allocate_device();
if (!input_dev) {
dev_err(&client->dev,"%s: could not allocate input device for heartbeat sensor\n", __FUNCTION__);
rc = -ENOMEM;
goto done;
}
data->hsensor_input_dev = input_dev;
input_set_drvdata(input_dev, data);
input_dev->name = "heartbeat";
input_dev->dev.parent = &client->dev;
set_bit(EV_ABS, input_dev->evbit);
input_set_abs_params(input_dev, ABS_WHEEL, 0, 8, 0, 0);
rc = input_register_device(input_dev);
if (rc < 0) {
pr_err("%s: could not register input device for heartbeat sensor\n", __FUNCTION__);
goto done;
}
done:
return rc;
}
static int ap3426_ls_enable(struct ap3426_data *ps_data,int enable)
{
int32_t ret;
LDBG("%s, misc_ls_opened = %d, enable=%d\n", __func__, misc_ls_opened, enable);
if(ps_data->rels_enable == 1)
{
//it will be judge the status when resume kevindang20140925
ps_data->rels_enable = 0;
}
else if(misc_ls_opened == enable)
{
// normal kevindang20140925
return 0;
}
misc_ls_opened = enable;
ret = __ap3426_write_reg(ps_data->client,
AP3426_REG_SYS_CONF, AP3426_REG_SYS_INT_AMASK, 0, enable);
if(ret < 0){
printk("ls enable error!!!!!!\n");
}
if(enable)
enable_irq(ps_data->client->irq);
else
disable_irq_nosync(ps_data->client->irq);
// enable_irq(ps_data->client->irq);
ret = mod_timer(&ps_data->pl_timer, jiffies + msecs_to_jiffies(PL_TIMER_DELAY));
return ret;
}
static int ap3426_get_adc_value(struct i2c_client *client)
{
unsigned int lsb, msb, val;
#ifdef LSC_DBG
unsigned int tmp,range;
#endif
lsb = i2c_smbus_read_byte_data(client, AP3426_REG_ALS_DATA_LOW);
if (lsb < 0) {
return lsb;
}
msb = i2c_smbus_read_byte_data(client, AP3426_REG_ALS_DATA_HIGH);
if (msb < 0)
return msb;
#ifdef LSC_DBG
range = ap3426_get_range(client);
tmp = (((msb << 8) | lsb) * range) >> 16;
tmp = tmp * cali / 100;
LDBG("ALS val=%d lux\n",tmp);
#endif
val = msb << 8 | lsb;
return val;
}
static ssize_t ap3426_store_calibration_state(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);
int stdls, lux;
char tmp[10];
LDBG("DEBUG ap3426_store_calibration_state..\n");
/* No LUX data if not operational */
if (ap3426_get_mode(data->client) == AP3426_SYS_DEV_DOWN)
{
printk("Please power up first!");
return -EINVAL;
}
cali = 100;
sscanf(buf, "%d %s", &stdls, tmp);
if (!strncmp(tmp, "-setcv", 6))
{
cali = stdls;
return -EBUSY;
}
if (stdls < 0)
{
printk("Std light source: [%d] < 0 !!!\nCheck again, please.\n\
Set calibration factor to 100.\n", stdls);
return -EBUSY;
}
static void fsg_lun_close(struct fsg_lun *curlun)
{
if (curlun->filp) {
LDBG(curlun, "close backing file\n");
fput(curlun->filp);
curlun->filp = NULL;
}
}
static int ap3426_get_px_value(struct i2c_client *client)
{
int lsb, msb;
lsb = i2c_smbus_read_byte_data(client, AP3426_REG_PS_DATA_LOW);
if (lsb < 0)
return lsb;
LDBG("%s, IR = %d\n", __func__, (u32)(lsb));
msb = i2c_smbus_read_byte_data(client, AP3426_REG_PS_DATA_HIGH);
if (msb < 0)
return msb;
LDBG("%s, IR = %d\n", __func__, (u32)(msb));
return (u32)(((msb & AL3426_REG_PS_DATA_HIGH_MASK) << 8) | (lsb & AL3426_REG_PS_DATA_LOW_MASK));
}
static int ap3426_get_object(struct i2c_client *client)
{
int val;
val = i2c_smbus_read_byte_data(client, AP3426_OBJ_COMMAND);
LDBG("val=%x\n", val);
val &= AP3426_OBJ_MASK;
// return val >> AP3426_OBJ_SHIFT;
return !(val >> AP3426_OBJ_SHIFT);
}
static ssize_t ap3426_store_mode(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 > 7))
return -EINVAL;
ret = ap3426_set_mode(data->client, val);
if (ret < 0)
return ret;
LDBG("Starting timer to fire in 200ms (%ld)\n", jiffies );
ret = mod_timer(&data->pl_timer, jiffies + msecs_to_jiffies(PL_TIMER_DELAY));
if(ret)
LDBG("Timer Error\n");
return count;
}
static ssize_t ps_enable_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t size)
{
struct ap3426_data *ps_data = dev_get_drvdata(dev);
uint8_t en;
if (sysfs_streq(buf, "1"))
en = 1;
else if (sysfs_streq(buf, "0"))
en = 0;
else
{
printk(KERN_ERR "%s, invalid value %d\n", __func__, *buf);
return -EINVAL;
}
LDBG("%s, en = %d\n", __func__, (u32)(en));
ap3426_ps_enable(ps_data, en);
return size;
}
static void fsg_lun_close(struct fsg_lun *curlun)
{
struct inode *inode = NULL;
struct backing_dev_info *bdi;
if (curlun->filp) {
inode = file_inode(curlun->filp);
if (inode->i_bdev) {
bdi = &inode->i_bdev->bd_queue->backing_dev_info;
if ((bdi->capabilities & BDI_CAP_STRICTLIMIT) &&
bdi_set_max_ratio(bdi, curlun->max_ratio))
pr_debug("%s, error in setting max_ratio\n",
__func__);
}
LDBG(curlun, "close backing file\n");
fput(curlun->filp);
curlun->filp = NULL;
}
}
static int fsg_lun_open(struct fsg_lun *curlun, const char *filename)
{
int ro;
struct file *filp = NULL;
int rc = -EINVAL;
struct inode *inode = NULL;
loff_t size;
loff_t num_sectors;
loff_t min_sectors;
unsigned int blkbits;
unsigned int blksize;
/* R/W if we can, R/O if we must */
ro = curlun->initially_ro;
if (!ro) {
filp = filp_open(filename, O_RDWR | O_LARGEFILE, 0);
if (PTR_ERR(filp) == -EROFS || PTR_ERR(filp) == -EACCES)
ro = 1;
}
if (ro)
filp = filp_open(filename, O_RDONLY | O_LARGEFILE, 0);
if (IS_ERR(filp)) {
LINFO(curlun, "unable to open backing file: %s\n", filename);
return PTR_ERR(filp);
}
if (!(filp->f_mode & FMODE_WRITE))
ro = 1;
inode = file_inode(filp);
if ((!S_ISREG(inode->i_mode) && !S_ISBLK(inode->i_mode))) {
LINFO(curlun, "invalid file type: %s\n", filename);
goto out;
}
/*
* If we can't read the file, it's no good.
* If we can't write the file, use it read-only.
*/
if (!(filp->f_op->read || filp->f_op->aio_read)) {
LINFO(curlun, "file not readable: %s\n", filename);
goto out;
}
if (!(filp->f_op->write || filp->f_op->aio_write))
ro = 1;
size = i_size_read(inode->i_mapping->host);
if (size < 0) {
LINFO(curlun, "unable to find file size: %s\n", filename);
rc = (int) size;
goto out;
}
/*
* curlun->blksize remains the old value when switch from cdrom to udisk
* so use the same blksie in cdrom and udisk
*/
#ifdef CONFIG_HUAWEI_USB
if (inode->i_bdev) {
blksize = bdev_logical_block_size(inode->i_bdev);
blkbits = blksize_bits(blksize);
} else {
blksize = 512;
blkbits = 9;
}
#else
if (curlun->cdrom) {
blksize = 2048;
blkbits = 11;
} else if (inode->i_bdev) {
blksize = bdev_logical_block_size(inode->i_bdev);
blkbits = blksize_bits(blksize);
} else {
blksize = 512;
blkbits = 9;
}
#endif
num_sectors = size >> blkbits; /* File size in logic-block-size blocks */
min_sectors = 1;
#ifndef CONFIG_HUAWEI_USB
if (curlun->cdrom) {
min_sectors = 300; /* Smallest track is 300 frames */
if (num_sectors >= 256*60*75) {
num_sectors = 256*60*75 - 1;
LINFO(curlun, "file too big: %s\n", filename);
LINFO(curlun, "using only first %d blocks\n",
(int) num_sectors);
}
}
#endif
if (num_sectors < min_sectors) {
LINFO(curlun, "file too small: %s\n", filename);
rc = -ETOOSMALL;
goto out;
}
if (fsg_lun_is_open(curlun))
fsg_lun_close(curlun);
curlun->blksize = blksize;
curlun->blkbits = blkbits;
curlun->ro = ro;
curlun->filp = filp;
curlun->file_length = size;
curlun->num_sectors = num_sectors;
LDBG(curlun, "open backing file: %s\n", filename);
return 0;
out:
fput(filp);
return rc;
}
static int fsg_lun_open(struct fsg_lun *curlun, const char *filename)
{
int ro;
struct file *filp = NULL;
int rc = -EINVAL;
struct inode *inode = NULL;
struct backing_dev_info *bdi;
loff_t size;
loff_t num_sectors;
loff_t min_sectors;
unsigned int blkbits;
unsigned int blksize;
/* R/W if we can, R/O if we must */
ro = curlun->initially_ro;
if (!ro) {
filp = filp_open(filename, O_RDWR | O_LARGEFILE, 0);
if (PTR_ERR(filp) == -EROFS || PTR_ERR(filp) == -EACCES)
ro = 1;
}
if (ro)
filp = filp_open(filename, O_RDONLY | O_LARGEFILE, 0);
if (IS_ERR(filp)) {
LINFO(curlun, "unable to open backing file: %s\n", filename);
return PTR_ERR(filp);
}
if (!(filp->f_mode & FMODE_WRITE))
ro = 1;
inode = file_inode(filp);
if ((!S_ISREG(inode->i_mode) && !S_ISBLK(inode->i_mode))) {
LINFO(curlun, "invalid file type: %s\n", filename);
goto out;
}
/*
* If we can't read the file, it's no good.
* If we can't write the file, use it read-only.
*/
if (!(filp->f_op->read || filp->f_op->aio_read)) {
LINFO(curlun, "file not readable: %s\n", filename);
goto out;
}
if (!(filp->f_op->write || filp->f_op->aio_write))
ro = 1;
size = i_size_read(inode->i_mapping->host);
if (size < 0) {
LINFO(curlun, "unable to find file size: %s\n", filename);
rc = (int) size;
goto out;
}
if (curlun->cdrom) {
blksize = 2048;
blkbits = 11;
} else if (inode->i_bdev) {
blksize = bdev_logical_block_size(inode->i_bdev);
blkbits = blksize_bits(blksize);
bdi = &inode->i_bdev->bd_queue->backing_dev_info;
if (bdi->capabilities & BDI_CAP_STRICTLIMIT) {
curlun->max_ratio = bdi->max_ratio;
curlun->nofua = 1;
if (bdi_set_max_ratio(bdi, uicc_ums_max_ratio))
pr_debug("%s, error in setting max_ratio\n",
__func__);
}
} else {
blksize = 512;
blkbits = 9;
}
num_sectors = size >> blkbits; /* File size in logic-block-size blocks */
min_sectors = 1;
if (curlun->cdrom) {
min_sectors = 300; /* Smallest track is 300 frames */
if (num_sectors >= 256*60*75) {
num_sectors = 256*60*75 - 1;
LINFO(curlun, "file too big: %s\n", filename);
LINFO(curlun, "using only first %d blocks\n",
(int) num_sectors);
}
}
if (num_sectors < min_sectors) {
LINFO(curlun, "file too small: %s\n", filename);
rc = -ETOOSMALL;
goto out;
}
if (fsg_lun_is_open(curlun))
fsg_lun_close(curlun);
curlun->blksize = blksize;
curlun->blkbits = blkbits;
curlun->ro = ro;
curlun->filp = filp;
curlun->file_length = size;
curlun->num_sectors = num_sectors;
LDBG(curlun, "open backing file: %s\n", filename);
return 0;
out:
fput(filp);
return rc;
}
