static int mxc6225_sensor_chip_readid(struct cavan_input_chip *chip)
{
int ret;
u8 id;
ret = chip->read_register(chip, REG_CHIP_ID, &id);
if (ret < 0) {
pr_red_info("cavan_sensor_i2c_read_register");
return ret;
}
chip->devid = id & 0x3F;
pr_bold_info("Device ID = 0x%02x = 0x%02x", id, chip->devid);
switch (chip->devid) {
case CHIP_ID_MXC6225XC:
chip->name = "MXC6225XC";
break;
case CHIP_ID_MXC6225XU:
chip->name = "MXC6225XU";
break;
default:
pr_red_info("Invalid Chip ID 0x%02x", chip->devid);
}
pr_bold_info("This chip is %s", chip->name);
return 0;
}
static int adxl34x_sensor_chip_readid(struct hua_input_chip *chip)
{
int ret;
u8 id;
ret = chip->read_register(chip, DEVID, &id);
if (ret < 0)
{
pr_red_info("hua_sensor_i2c_read_register");
return ret;
}
pr_bold_info("Device ID = 0x%02x", id);
switch (id)
{
case ID_ADXL345:
chip->devid = 0x0345;
chip->name = "ADXL345";
break;
case ID_ADXL346:
chip->devid = 0x0346;
chip->name = "ADXL346";
break;
default:
pr_red_info("Invalid device id = 0x%02x", id);
return -EINVAL;
}
pr_bold_info("This sendor is %s", chip->name);
return 0;
}
static int huamobile_touch_device_probe(struct huamobile_touch_device *dev, void *data)
{
int ret;
int min, max, diff;
int fd = dev->input_dev.event_dev->fd;
struct huamobile_input_service *service = data;
pr_pos_info();
pr_bold_info("lcd_width = %d, lcd_height = %d", service->lcd_width, service->lcd_height);
if (service->lcd_width > 0)
{
ret = huamobile_event_get_absinfo(fd, dev->xaxis, &min, &max);
if (ret < 0)
{
pr_red_info("huamobile_event_get_absinfo");
return ret;
}
pr_bold_info("x-min = %d, x-max = %d", min, max);
diff = max - min;
dev->xscale = ((double)service->lcd_width) / diff;
dev->xoffset = ((double)service->lcd_width) * min / diff;
}
else
{
dev->xscale = 1;
dev->xoffset = 0;
}
if (service->lcd_height > 0)
{
ret = huamobile_event_get_absinfo(fd, dev->yaxis, &min, &max);
if (ret < 0)
{
pr_red_info("huamobile_event_get_absinfo");
return ret;
}
pr_bold_info("y-min = %d, y-max = %d", min, max);
diff = max - min;
dev->yscale = ((double)service->lcd_height) / diff;
dev->yoffset = ((double)service->lcd_height) * min / diff;
}
else
{
dev->yscale = 1;
dev->yoffset = 0;
}
pr_bold_info("xscale = %lf, xoffset = %lf", dev->xscale, dev->xoffset);
pr_bold_info("yscale = %lf, yoffset = %lf", dev->yscale, dev->yoffset);
return 0;
}
static int cy8c242_enter_upgrade_mode(struct cavan_input_chip *chip, int retry)
{
while (retry--) {
int ret;
u8 value;
cavan_io_set_power_regulator(chip, false);
cavan_io_irq_gpio_set_value(chip, 0);
msleep(10);
cavan_io_set_power_regulator(chip, true);
msleep(50);
cavan_io_irq_gpio_set_value(chip, -1);
ret = chip->read_register(chip, 0x01, &value);
if (ret < 0) {
pr_red_info("cavan_i2c_read_register");
return ret;
}
pr_bold_info("value = 0x%02x", value);
if (value == 0x11 || value == 0x10) {
return 0;
}
}
return -ETIMEDOUT;
}
void show_ext2_inode(const struct ext2_inode *inode)
{
int i;
print_sep(60);
pr_bold_info("ext2 inode %p", inode);
println("mode = 0x%05o", inode->mode);
println("uid = %d", inode->uid);
println("size = %d", inode->size);
println("atime = %d", inode->atime);
println("ctime = %d", inode->ctime);
println("mtime = %d", inode->mtime);
println("dtime = %d", inode->dtime);
println("gid = %d", inode->gid);
println("links_count = %d", inode->links_count);
println("blocks = %d", inode->blocks);
println("flags = 0x%08x", inode->flags);
println("version = %d", inode->version);
println("file_acl = %d", inode->file_acl);
println("dir_acl = %d", inode->dir_acl);
println("faddr = %d", inode->faddr);
if ((inode->flags & EXT2_INODE_FLAG_EXTENTS) == 0)
{
for (i = 0; i < EXT2_N_BLOCKS; i++)
{
println("inode->block[%d] = %d", i, inode->block[i]);
}
}
}
static int cy8c242_exit_upgrade_mode(struct cavan_input_chip *chip, int retry)
{
int ret;
u8 value;
msleep(200);
while (retry--) {
cy8c242_ts_reset(chip);
msleep(100);
ret = chip->read_register(chip, 0x01, &value);
if (ret < 0) {
pr_red_info("cavan_i2c_read_register");
return ret;
}
pr_bold_info("value = 0x%02x", value);
if (value != 0x11 && value != 0x10) {
return 0;
}
}
return -ETIMEDOUT;
}
static int bma2xx_sensor_chip_set_active(struct cavan_input_chip *chip, bool enable)
{
int ret;
u8 value;
pr_pos_info();
ret = chip->read_register(chip, REG_MODE_CTRL, &value);
if (ret < 0) {
pr_red_info("read_register");
return ret;
}
if (enable) {
value &= ~(3 << 6);
} else {
value |= 1 << 7;
}
pr_bold_info("value = 0x%02x", value);
ret = chip->write_register(chip, REG_MODE_CTRL, value);
if (ret < 0) {
pr_red_info("write_register");
return ret;
}
return 0;
}
static int hua_ts_fb_notifier_call(struct notifier_block *notifier, unsigned long event, void *data)
{
struct fb_event *evdata = data;
struct hua_ts_device *ts = container_of(notifier, struct hua_ts_device, fb_notifier);
pr_bold_info("event = %ld", event);
if (evdata && event == FB_EVENT_BLANK)
{
int *blank = evdata->data;
if (blank)
{
if (*blank == FB_BLANK_UNBLANK)
{
hua_ts_resume(ts);
}
else if (*blank == FB_BLANK_POWERDOWN)
{
hua_ts_suspend(ts);
}
}
}
return 0;
}
static void showDexHeader(DexHeader *header)
{
pr_bold_info("DexHeader[%p]:", header);
println("magic = %s", header->magic);
// println("signature = %s", header->signature);
println("fileSize = %d", header->fileSize);
println("headerSize = %d", header->headerSize);
println("endianTag = %d", header->endianTag);
println("linkSize = %d", header->linkSize);
println("linkOff = %d", header->linkOff);
println("mapOff = %d", header->mapOff);
println("stringIdsSize = %d", header->stringIdsSize);
println("stringIdsOff = %d", header->stringIdsOff);
println("typeIdsSize = %d", header->typeIdsSize);
println("typeIdsOff = %d", header->typeIdsOff);
println("protoIdsSize = %d", header->protoIdsSize);
println("protoIdsOff = %d", header->protoIdsOff);
println("fieldIdsSize = %d", header->fieldIdsSize);
println("fieldIdsOff = %d", header->fieldIdsOff);
println("methodIdsSize = %d", header->methodIdsSize);
println("methodIdsOff = %d", header->methodIdsOff);
println("classDefsSize = %d", header->classDefsSize);
println("classDefsOff = %d", header->classDefsOff);
println("dataSize = %d", header->dataSize);
println("dataOff = %d", header->dataOff);
println("checksum = 0x%08x", header->checksum);
}
void show_ext4_extent_index(const struct ext4_extent_index *index)
{
print_sep(60);
pr_bold_info("ext4 extent index %p", index);
println("block = %d", index->block);
println("leaf = %" PRINT_FORMAT_INT64, (u64) index->leaf_hi << 32 | index->leaf_lo);
}
int cavan_thread_send_event(struct cavan_thread *thread, u32 event)
{
#if CAVAN_THREAD_DEBUG
pr_bold_info("send event %d", event);
#endif
return write(thread->wr_event_fd, &event, sizeof(event));
}
void show_ext4_extent_leaf(const struct ext4_extent_leaf *leaf)
{
print_sep(60);
pr_bold_info("ext4 extent leaf %p", leaf);
println("block = %d", leaf->block);
println("length = %d", leaf->length);
println("start = %" PRINT_FORMAT_INT64, (u64) leaf->start_hi << 32 | leaf->start_lo);
}
const struct cavan_sensor_rate_table_node *cavan_sensor_find_rate_value(const struct cavan_sensor_rate_table_node *table, size_t count, u32 delay_ns)
{
const struct cavan_sensor_rate_table_node *p;
for (p = table + count - 1; p > table && p->delay_ns > delay_ns; p--);
pr_bold_info("value = 0x%02x, delay = %d, relly_delay = %d", p->value, delay_ns, p->delay_ns);
return p;
}
static int cavan_touchpad_probe(struct cavan_input_device *dev, void *data)
{
int ret;
int min, max, diff;
int width, height;
int fd = dev->event_dev->fd;
struct cavan_touchpad_device *touchpad = (struct cavan_touchpad_device *) dev;
struct cavan_input_service *service = data;
pr_bold_info("LCD: width = %d, height = %d", service->lcd_width, service->lcd_height);
ret = cavan_event_get_absinfo(fd, ABS_X, &min, &max);
if (ret < 0)
{
pr_red_info("cavan_event_get_absinfo");
return ret;
}
diff = max - min;
width = service->lcd_height > 0 ? service->lcd_height : diff;
pr_bold_info("x-min = %d, x-max = %d, diff = %d, width = %d", min, max, diff, width);
touchpad->xspeed = ((double) width) / diff;
touchpad->right = max - (diff >> CAVAN_TOUCHPAD_EDGE_SHIFT);
pr_bold_info("xspeed = %lf, right = %d", touchpad->xspeed, touchpad->right);
ret = cavan_event_get_absinfo(fd, ABS_Y, &min, &max);
if (ret < 0)
{
pr_red_info("cavan_event_get_absinfo");
return ret;
}
diff = max - min;
height = service->lcd_height > 0 ? service->lcd_height : diff;
pr_bold_info("y-min = %d, y-max = %d, diff = %d, height = %d", min, max, diff, height);
touchpad->yspeed = ((double) height) / diff;
touchpad->bottom = max - (diff >> CAVAN_TOUCHPAD_EDGE_SHIFT);
pr_bold_info("yspeed = %lf, bottom = %d", touchpad->yspeed, touchpad->bottom);
return 0;
}
static void cavan_thread_sighandler(int signum)
{
#if CAVAN_THREAD_DEBUG
pr_bold_info("signum = %d", signum);
#endif
if (signum == SIGUSR1) {
pthread_exit(0);
}
}
void show_ext2_directory_entry(const struct ext2_directory_entry *dir_entry)
{
print_sep(60);
pr_bold_info("ext2 directory entry %p", dir_entry);
println("file_type = %d", dir_entry->file_type);
println("inode = %d", dir_entry->inode);
println("name = %s", dir_entry->name);
println("name_len = %d", dir_entry->name_len);
println("rec_len = %d", dir_entry->rec_len);
}
void show_ext4_extent_header(const struct ext4_extent_header *header)
{
print_sep(60);
pr_bold_info("ext4 extent header %p", header);
println("magic = 0x%04x", header->magic);
println("entries = %d", header->entries);
println("max_entries = %d", header->max_entries);
println("depth = %d", header->depth);
println("generations = %d", header->generations);
}
void cavan_show_date(struct tm *date, const char *prompt)
{
if (prompt == NULL)
{
prompt = "";
}
pr_bold_info("%s%04d-%02d-%02d %02d:%02d:%02d", prompt,
date->tm_year + 1900, date->tm_mon + 1, date->tm_mday,
date->tm_hour, date->tm_min, date->tm_sec);
// pr_bold_info("tm_wday = %d, tm_yday = %d, tm_isdst = %d", date->tm_wday, date->tm_yday, date->tm_isdst);
}
void show_ext2_group_desc(const struct ext2_group_desc *group_desc)
{
print_sep(60);
pr_bold_info("ext2 group desc %p", group_desc);
println("block_bitmap = %d", group_desc->block_bitmap);
println("inode_bitmap = %d", group_desc->inode_bitmap);
println("inode_table = %d", group_desc->inode_table);
println("free_blocks_count = %d", group_desc->free_blocks_count);
println("free_inodes_count = %d", group_desc->free_inodes_count);
println("used_dirs_count = %d", group_desc->used_dirs_count);
println("pad = %d", group_desc->pad);
}
static void showDexOptHeader(DexOptHeader *header)
{
pr_bold_info("DexOptHeader[%p]:", header);
println("magic = %s", header->magic);
println("dexOffset = %d", header->dexOffset);
println("dexLength = %d", header->dexLength);
println("depsOffset = %d", header->depsOffset);
println("depsLength = %d", header->depsLength);
println("optOffset = %d", header->optOffset);
println("optLength = %d", header->optLength);
println("flags = 0x%08x", header->flags);
println("checksum = 0x%08x", header->checksum);
}
bool cavan_keypad_device_match(uint8_t *key_bitmask)
{
uint8_t *key, *key_end;
bool result = false;
for (key = key_bitmask, key_end = key + KEY_BITMASK_SIZE; key < key_end; key++) {
if (*key) {
result = true;
#if 0
#if __WORDSIZE == 64
pr_bold_info("key_bitmask[%ld] = 0x%02x", key - key_bitmask, *key);
#else
pr_bold_info("key_bitmask[%d] = 0x%02x", key - key_bitmask, *key);
#endif
#endif
*key = 0;
}
}
return result;
}
void *huamobule_file_read_all(const char *pathname, size_t *size)
{
int ret;
int fd;
struct stat st;
void *mem;
ssize_t rdlen;
pr_bold_info("pathname = %s", pathname);
fd = open(pathname, O_RDONLY);
if (fd < 0)
{
pr_error_info("open file %s", pathname);
return NULL;
}
ret = fstat(fd, &st);
if (ret < 0)
{
pr_error_info("get file `%s' stat", pathname);
close(fd);
return NULL;
}
mem = malloc(st.st_size);
if (mem == NULL)
{
pr_error_info("malloc");
close(fd);
return NULL;
}
rdlen = read(fd, mem, st.st_size);
if (rdlen < 0)
{
pr_error_info("read");
free(mem);
mem = NULL;
}
else
{
*size = rdlen;
}
close(fd);
return mem;
}
static int bma2xx_sensor_chip_readid(struct cavan_input_chip *chip)
{
int ret;
u8 value;
ret = chip->read_register(chip, REG_CHIP_ID, &value);
if (ret < 0) {
pr_red_info("read_register REG_MODE");
return ret;
}
pr_bold_info("REG_CHIP_ID = 0x%02x", value);
return 0;
}
int cavan_thread_recv_event(struct cavan_thread *thread, u32 *event)
{
int ret;
ret = read(thread->rd_event_fd, event, sizeof(*event));
if (ret < 0) {
pr_red_info("read");
return ret;
}
#if CAVAN_THREAD_DEBUG
pr_bold_info("receive event %d", *event);
#endif
return ret;
}
static int cy8c242_change_power_mode(struct cavan_input_chip *chip, u8 mode, int retry)
{
pr_bold_info("CY8C242 change power mode => %s", cy8c242_power_mode_tostring(mode));
while (chip->write_register(chip, CY8C242_REG_POWER_MODE, mode) < 0 && retry--) {
msleep(10);
}
if (retry < 0) {
pr_red_info("Failed");
} else {
pr_green_info("OK");
}
return retry;
}
static int swan_ts_get_client_address_main(int argc, char *argv[])
{
int ret;
u16 addr;
ret = swan_ts_get_client_address(argc > 1 ? argv[1] : NULL, &addr);
if (ret < 0)
{
pr_red_info("swan_ts_get_client_address");
return ret;
}
pr_bold_info("Client address = %d = 0x%04x", addr, addr);
return 0;
}
static int ltr553_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
int ret;
struct cavan_input_chip *chip;
pr_pos_info();
chip = kzalloc(sizeof(*chip), GFP_KERNEL);
if (chip == NULL) {
pr_red_info("kzalloc");
return -ENOMEM;
}
i2c_set_clientdata(client, chip);
cavan_input_chip_set_bus_data(chip, client);
#if LTR553_SUPPORT_IRQ
chip->irq = client->irq;
chip->irq_flags = IRQF_TRIGGER_FALLING;
#else
chip->irq = -1;
#endif
pr_bold_info("chip->irq = %d", chip->irq);
chip->name = "LTR553";
chip->flags = CAVAN_INPUT_CHIP_FLAG_POWERON_INIT;
chip->devmask = 1 << CAVAN_INPUT_DEVICE_TYPE_PROXIMITY | 1 << CAVAN_INPUT_DEVICE_TYPE_LIGHT;
chip->read_data = cavan_input_read_data_i2c;
chip->write_data = cavan_input_write_data_i2c_single;
chip->readid = ltr553_sensor_chip_readid;
chip->probe = ltr553_input_chip_probe;
chip->remove = ltr553_input_chip_remove;
ret = cavan_input_chip_register(chip, &client->dev);
if (ret < 0) {
pr_red_info("cavan_input_chip_register");
goto out_kfree_chip;
}
return 0;
out_kfree_chip:
kfree(chip);
return ret;
}
int swan_ts_calibration(const char *devpath)
{
int fd;
int ret;
fd = swan_ts_open_misc_device(devpath, 0);
if (fd < 0) {
pr_bold_info("Retry use input calibration");
return swan_ts_input_calibration(devpath);
}
ret = ioctl(fd, SWAN_TS_IOCTL_CALIBRATION);
close(fd);
return ret;
}
static int swan_ts_match_handler(struct cavan_event_matcher *matcher, void *data)
{
int ret;
pr_info("Device \"%s\" is named \"%s\"", matcher->pathname, matcher->devname);
pr_bold_info("Calibration, don't touch the screen");
ret = ioctl(matcher->fd, SWAN_TS_INPUT_IOCTL_CALIBRATION);
if (ret < 0) {
pr_error_info("ioctl SWAN_TS_INPUT_IOCTL_CALIBRATION");
return ret;
}
close(matcher->fd);
return 0;
}
ssize_t cy8c242_ts_calibration(struct cavan_input_device *dev, char *buff, size_t size, bool store)
{
int ret;
u8 value;
int i;
char data[2] = {0x1C, 0x01};
struct cavan_input_chip *chip = dev->chip;
pr_pos_info();
for (i = 0; i < 5; i++) {
cy8c242_ts_reset(chip);
msleep(100);
ret = chip->master_send(chip, data, sizeof(data));
if (ret < 0) {
pr_red_info("master_send");
return ret;
}
msleep(1000);
ret = chip->master_send(chip, data, 1);
if (ret < 0) {
pr_red_info("master_send");
return ret;
}
ret = chip->master_recv(chip, &value, 1);
if (ret < 0) {
pr_red_info("master_recv");
return ret;
}
pr_bold_info("value[%d] = %d", i, value);
if (value == 0) {
return snprintf(buff, size, "%s calibration complete.\n", chip->name);
}
}
return -EFAULT;
}
