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