static void *read_thread_handler(void *data) { ssize_t rdlen; char buff[1024]; struct cavan_cache *cache = data; while (1) { rdlen = cavan_cache_read_line(cache, buff, sizeof(buff), 0, 20000); if (rdlen <= 0) { if (rdlen < 0) { pr_red_info("cavan_cache_read"); break; } else { rdlen = cavan_cache_read(cache, buff, sizeof(buff) - 1, 0, 0); if (rdlen <= 0) { break; } } } buff[rdlen] = 0; #if __WORDSIZE == 64 pr_green_info("buff[%ld] = %s", rdlen, buff); #else pr_green_info("buff[%d] = %s", rdlen, buff); #endif // msleep(500); } pr_red_info("Read thread exit!"); return NULL; }
int main(int argc, char *argv[]) { int ret; int stream; float volume; assert(argc > 1); stream = getStreamByName(argv[1]); if (stream < 0) { pr_red_info("getStreamByName"); return stream; } if (argc > 2) { volume = atoi(argv[2]); ret = setStreamVolume(stream, volume / 100); if (ret < 0) { pr_red_info("setStreamVolume"); } else { pr_green_info("setStreamVolume"); } } else { ret = getStreamVolume(stream, &volume); if (ret < 0) { pr_red_info("getStreamVolume"); } else { pr_green_info("volume = %f", volume); } } return 0; }
bool cavan_touch_device_matcher(struct cavan_event_matcher *matcher, void *data) { int ret; uint8_t abs_bitmask[ABS_BITMASK_SIZE]; uint8_t key_bitmask[KEY_BITMASK_SIZE]; ret = cavan_event_get_abs_bitmask(matcher->fd, abs_bitmask); if (ret < 0) { pr_error_info("cavan_event_get_abs_bitmask"); return false; } if (cavan_multi_touch_device_match(abs_bitmask)) { pr_green_info("Deivce %s mutil touch screen", matcher->devname); return true; } ret = cavan_event_get_key_bitmask(matcher->fd, key_bitmask); if (ret < 0) { pr_error_info("cavan_event_get_key_bitmask"); return false; } return cavan_single_touch_device_match(abs_bitmask, key_bitmask); }
int cavan_inotify_register_watch(struct cavan_inotify_descriptor *desc, const char *pathname, uint32_t mask, void *data) { int wd; struct cavan_inotify_watch *p; if (desc->watch_count >= NELEM(desc->watchs)) { error_msg("Too match watch"); return -EFAULT; } if (pathname == NULL || *pathname == 0) { error_msg("pathname == NULL || *pathname == 0"); return -EINVAL; } wd = inotify_add_watch(desc->fd, pathname, mask); if (wd < 0) { print_error("inotify_add_watch"); return wd; } for (p = desc->watchs; p->wd >= 0; p++); p->wd = wd; p->data = data; text_copy(p->pathname, pathname); desc->watch_count++; pr_green_info("Add watch: %s", pathname); return 0; }
static int swan_virtual_keypad_probe(struct platform_device *pdev) { int ret; struct device_attribute *p; pr_pos_info(); vk_input = input_allocate_device(); if (vk_input == NULL) { pr_red_info("input_allocate_device"); return -ENOMEM; } vk_input->name = SWAN_VK_DEVICE_NAME; swan_virtual_keypad_setup_events(vk_input); ret = input_register_device(vk_input); if (ret < 0) { pr_red_info("input_register_device"); goto out_input_free_device; } ret = misc_register(&swan_vk_misc); if (ret < 0) { pr_red_info("misc_register failed"); goto out_input_unregister_device; } for (p = vk_attrs + ARRAY_SIZE(vk_attrs) - 1; p >= vk_attrs; p--) { ret = device_create_file(&pdev->dev, p); if (ret < 0) { pr_red_info("device_create_file"); while (--p >= vk_attrs) { device_remove_file(&pdev->dev, p); } goto out_misc_deregister; } } pr_green_info("Swan Virtual Keypad is OK"); return 0; out_misc_deregister: misc_deregister(&swan_vk_misc); out_input_unregister_device: input_unregister_device(vk_input); out_input_free_device: input_free_device(vk_input); return ret; }
bool huamobile_touch_device_matcher(int fd, const char *name, void *data) { int ret; uint8_t abs_bitmask[ABS_BITMASK_SIZE]; uint8_t key_bitmask[KEY_BITMASK_SIZE]; pr_pos_info(); ret = huamobile_event_get_abs_bitmask(fd, abs_bitmask); if (ret < 0) { pr_error_info("huamobile_event_get_abs_bitmask"); return false; } if (huamobile_multi_touch_device_match(abs_bitmask)) { pr_green_info("Deivce %s mutil touch screen", name); return true; } ret = huamobile_event_get_key_bitmask(fd, key_bitmask); if (ret < 0) { pr_error_info("huamobile_event_get_key_bitmask"); return false; } return huamobile_single_touch_device_match(abs_bitmask, key_bitmask); }
int cavan_sensor_device_probe(struct cavan_input_device *dev) { int ret; struct input_dev *input = dev->input; struct cavan_sensor_device *sensor = (struct cavan_sensor_device *) dev; switch (dev->type) { case CAVAN_INPUT_DEVICE_TYPE_ACCELEROMETER: case CAVAN_INPUT_DEVICE_TYPE_MAGNETIC_FIELD: case CAVAN_INPUT_DEVICE_TYPE_ORIENTATION: case CAVAN_INPUT_DEVICE_TYPE_GYROSCOPE: case CAVAN_INPUT_DEVICE_TYPE_GRAVITY: case CAVAN_INPUT_DEVICE_TYPE_ROTATION_VECTOR: case CAVAN_INPUT_DEVICE_TYPE_LINEAR_ACCELERATION: if (sensor->axis_count < 2) { sensor->axis_count = 3; } input_set_abs_params(input, ABS_X, 0, sensor->resolution, dev->fuzz, dev->flat); input_set_abs_params(input, ABS_Y, 0, sensor->resolution, dev->fuzz, dev->flat); input_set_abs_params(input, ABS_Z, 0, sensor->resolution, dev->fuzz, dev->flat); break; case CAVAN_INPUT_DEVICE_TYPE_LIGHT: case CAVAN_INPUT_DEVICE_TYPE_PRESSURE: case CAVAN_INPUT_DEVICE_TYPE_TEMPERATURE: case CAVAN_INPUT_DEVICE_TYPE_PROXIMITY: sensor->axis_count = 1; input_set_abs_params(input, ABS_MISC, 0, sensor->resolution, dev->fuzz, dev->flat); break; default: pr_red_info("Invalid sensor type %d", dev->type); return -EINVAL; } set_bit(EV_ABS, input->evbit); ret = sysfs_create_files(&dev->misc_dev.dev->kobj, cavan_sensor_device_attributes); if (ret < 0) { pr_red_info("sysfs_create_files"); return ret; } dev->remove = cavan_sensor_device_remove; dev->ioctl = cavan_sensor_device_ioctl; pr_green_info("cavan sensor %s probe complete", dev->name); return 0; }
struct cavan_xml_tag *cavan_xml_tag_alloc(const char *name, const char *content, int flags) { struct cavan_xml_tag *tag; #if CONFIG_CAVAN_XML_DEBUG pr_green_info("tag: name = %s", name); #endif tag = malloc(sizeof(*tag)); if (tag == NULL) { pr_error_info("malloc"); return NULL; } tag->flags = 0; if (name && (flags & CAVAN_XML_FLAG_NAME_ALLOC)) { name = strdup(name); if (name == NULL) { goto out_free_tag; } tag->flags |= CAVAN_XML_FLAG_NAME_ALLOC; } if (content && (flags & CAVAN_XML_FLAG_CONTENT_ALLOC)) { content = strdup(content); if (content == NULL) { goto out_free_name; } tag->flags |= CAVAN_XML_FLAG_CONTENT_ALLOC; } tag->name = name; tag->content = content; tag->child = NULL; tag->next = NULL; tag->attr = NULL; return tag; out_free_name: if ((flags & CAVAN_XML_FLAG_NAME_ALLOC)) { free((char *) name); } out_free_tag: free(tag); return NULL; }
int swan_ts_test_client_fd(int fd, u16 addr) { int ret; println("Test client %d = 0x%04x", addr, addr); ret = ioctl(fd, SWAN_TS_IOCTL_TEST_CLIENT, &addr); if (ret < 0) { pr_red_info("Failed"); } else { pr_green_info("OK"); } return ret; }
struct cavan_xml_attribute *cavan_xml_attribute_alloc(const char *name, const char *value, int flags) { struct cavan_xml_attribute *attr; #if CONFIG_CAVAN_XML_DEBUG pr_green_info("attr: name = %s, value = %s", name, value); #endif attr = malloc(sizeof(*attr)); if (attr == NULL) { pr_error_info("malloc"); return NULL; } attr->flags = 0; if (name && (flags & CAVAN_XML_FLAG_NAME_ALLOC)) { name = strdup(name); if (name == NULL) { goto out_free_attr; } attr->flags |= CAVAN_XML_FLAG_NAME_ALLOC; } if (value && (flags & CAVAN_XML_FLAG_VALUE_ALLOC)) { value = strdup(value); if (value == NULL) { goto out_free_name; } attr->flags |= CAVAN_XML_FLAG_VALUE_ALLOC; } attr->name = name; attr->value = value; attr->next = NULL; return attr; out_free_name: if ((flags & CAVAN_XML_FLAG_NAME_ALLOC)) { free((char *) name); } out_free_attr: free(attr); return NULL; }
static int cy8c242_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); chip->irq = client->irq; chip->irq_flags = IRQF_TRIGGER_FALLING; chip->name = "CY8C242"; chip->devmask = 1 << CAVAN_INPUT_DEVICE_TYPE_TOUCHSCREEN | 1 << CAVAN_INPUT_DEVICE_TYPE_PROXIMITY; chip->set_power = cy8c242_set_power; chip->set_active = cy8c242_set_active; chip->readid = cy8c242_readid; chip->probe = cy8c242_input_chip_probe; chip->remove = cy8c242_input_chip_remove; chip->read_data = cavan_input_read_data_i2c; chip->write_data = cavan_input_write_data_i2c; chip->read_register = cavan_input_read_register_i2c_smbus; chip->write_register = cavan_input_write_register_i2c_smbus; chip->firmware_upgrade = cy8c242_firmware_upgrade; chip->read_firmware_id = cy8c242_read_firmware_id; ret = cavan_input_chip_register(chip, &client->dev); if (ret < 0) { pr_red_info("cavan_input_chip_register"); goto out_kfree_chip; } pr_green_info("CY8C242 Probe Complete"); return 0; out_kfree_chip: kfree(chip); return ret; }
static int swan_ts_calication_main(int argc, char *argv[]) { int ret; ret = swan_ts_calibration(argc > 1 ? argv[1] : NULL); if (ret < 0) { pr_red_info("Failed"); } else { pr_green_info("OK"); } 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 bl86x8_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id) { int ret; struct hua_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); hua_input_chip_set_bus_data(chip, client); chip->irq = client->irq; chip->irq_flags = IRQF_TRIGGER_FALLING; chip->name = "BL86X8"; chip->devmask = 1 << HUA_INPUT_DEVICE_TYPE_TOUCHSCREEN | 1 << HUA_INPUT_DEVICE_TYPE_PROXIMITY; chip->set_power = bl86x8_set_power; chip->readid = bl86x8_readid; chip->probe = bl86x8_input_chip_probe; chip->remove = bl86x8_input_chip_remove; chip->read_data = hua_input_read_data_i2c; chip->write_data = hua_input_write_data_i2c; chip->read_register = hua_input_read_register_i2c_smbus; chip->write_register = hua_input_write_register_i2c_smbus; ret = hua_input_chip_register(chip, &client->dev); if (ret < 0) { pr_red_info("hua_input_chip_register"); goto out_kfree_chip; } pr_green_info("BL86X8 Probe Complete"); return 0; out_kfree_chip: kfree(chip); return ret; }
void show_eth_header(struct ethhdr *ethhdr) { char buff[20]; memset(buff, 0, sizeof(buff)); pr_green_info("Ethhdr Header"); pr_std_info("dest_mac = %s", mac_address_tostring((const char *)ethhdr->h_dest, sizeof(ethhdr->h_dest), (const char *)buff)); pr_std_info("src_mac = %s", mac_address_tostring((const char *)ethhdr->h_source, sizeof(ethhdr->h_source), (const char *)buff)); pr_std_info("protocol_type = %x", ntohs(ethhdr->h_proto)); pr_std_info(""); }
static ssize_t swan_virtual_keypad_command_store(struct device *dev, struct device_attribute *attr, const char *buff, size_t count) { const struct swan_virtual_key *p, *end_p; static unsigned int old_code; pr_pos_info(); for (p = swan_vk_table, end_p = swan_vk_table + ARRAY_SIZE(swan_vk_table); p < end_p && strlhcmp(p->name, buff); p++); if (p < end_p) { old_code = p->code; } pr_green_info("keycode = %d", old_code); swan_vk_touch(vk_input, old_code); return count; }
int odexCheck2(const char *pathname) { int fd; int ret; fd = open(pathname, O_RDONLY); if (fd < 0) { pr_red_info("open file %s failed", pathname); return fd; } ret = odexCheck(fd); if (ret < 0) { pr_red_info("%s failed", pathname); } else { pr_green_info("%s passed", pathname); } close(fd); return ret; }
static int ft5406_firmware_upgrade_main(int argc, char *argv[]) { int ret; const char *cfgpath, *devpath; assert(argc > 1); cfgpath = argv[1]; devpath = argc > 2 ? argv[2] : NULL; ret = ft5406_firmware_upgrade(devpath, cfgpath); if (ret < 0) { pr_red_info("Failed"); } else { pr_green_info("OK"); } return ret; }
static int tcp_keypad_probe(struct platform_device *pdev) { int ret; pr_pos_info(); vk_input = input_allocate_device(); if (vk_input == NULL) { pr_red_info("input_allocate_device"); return -ENOMEM; } vk_input->name = TCP_KEYPAD_INPUT_NAME; tcp_keypad_setup_events(vk_input); ret = input_register_device(vk_input); if (ret < 0) { pr_red_info("input_register_device"); goto out_input_free_device; } ret = misc_register(&tcp_keypad_misc); if (ret < 0) { pr_red_info("misc_register failed"); goto out_input_unregister_device; } pr_green_info("Swan Virtual Keypad is OK"); return 0; out_input_unregister_device: input_unregister_device(vk_input); out_input_free_device: input_free_device(vk_input); return ret; }
static int swan_ts_write_registers_main(int argc, char *argv[]) { int i; int ret; char *buff; u16 offset; u16 count; assert(argc > 2); offset = text2value_unsigned(argv[1], NULL, 10); count = argc - 2; buff = malloc(count); for (i = 0; i < count; i++) { buff[i] = text2value_unsigned(argv[i + 2], NULL, 10); } println("offset = %d, count = %d", offset, count); println("The data is:"); print_mem((u8 *) buff, count); ret = swan_ts_write_registers(NULL, offset, buff, count); if (ret < 0) { pr_red_info("Failed"); } else { pr_green_info("OK"); } free(buff); return ret; }
static int mksdcard(const char *sd_device) { int ret; umount_device(sd_device, MNT_DETACH); ret = system_command("sfdisk %s -uM << EOF\n64,,L\nEOF", sd_device); if (ret < 0) { pr_err_info("system_command"); return ret; } sleep(1); ret = system_command("mkfs.vfat %s1 -n sdcard", sd_device); if (ret < 0) { pr_err_info("system_command"); return ret; } pr_green_info("mksdcard Success"); return 0; }
static struct cavan_input_device *cavan_input_device_create(uint8_t *key_bitmask, uint8_t *abs_bitmask, uint8_t *rel_bitmask) { #if CAVAN_INPUT_SUPPORT_GSENSOR if (cavan_gsensor_device_match(abs_bitmask)) { pr_green_info("G-Sensor Matched"); return cavan_gsensor_create(); } #endif if (cavan_touchpad_device_match(key_bitmask, abs_bitmask)) { pr_green_info("Touch Pad Matched"); return cavan_touchpad_device_create(); } if (cavan_multi_touch_device_match(abs_bitmask)) { pr_green_info("Muti Touch Panel Matched"); return cavan_multi_touch_device_create(); } if (cavan_single_touch_device_match(abs_bitmask, key_bitmask)) { pr_green_info("Single Touch Panel Matched"); return cavan_single_touch_device_create(); } if (cavan_mouse_device_match(key_bitmask, rel_bitmask)) { pr_green_info("Mouse Matched"); return cavan_mouse_create(); } if (cavan_keypad_device_match(key_bitmask)) { pr_green_info("Keypad Matched"); return cavan_keypad_create(); } return NULL; }
int bootimg_pack(struct bootimg_pack_option *option) { int fd; int ret; int image_count; struct bootimg_header hdr; struct bootimg_image images[4]; struct bootimg_image *p, *p_end; struct cavan_sha_context context; if (option->kernel == NULL || option->ramdisk == NULL) { pr_red_info("no kernel or ramdisk image specified"); return -EINVAL; } fd = open(option->output, O_WRONLY | O_CREAT | O_TRUNC, 0777); if (fd < 0) { pr_error_info("open file `%s' failed", option->output); return fd; } ret = lseek(fd, sizeof(hdr), SEEK_SET); if (ret < 0) { pr_red_info("cavan_file_seek_page_align"); goto out_close_fd; } cavan_sha1_context_init(&context); ret = cavan_sha_init(&context); if (ret < 0) { pr_red_info("cavan_sha_init"); goto out_close_fd; } memset(&hdr, 0, sizeof(hdr)); memcpy(hdr.magic, BOOT_MAGIC, sizeof(hdr.magic)); if (option->config) { ret = bootimg_parse_config_file(&hdr, option->config); if (ret < 0) { pr_red_info("bootimg_parse_config_file"); goto out_close_fd; } } else { memcpy(hdr.unused, option->unused, sizeof(hdr.unused)); hdr.page_size = option->page_size; hdr.kernel_addr = option->kernel_addr ?: option->base + option->kernel_offset; hdr.ramdisk_addr = option->ramdisk_addr ?: option->base + option->ramdisk_offset; hdr.second_addr = option->second_addr ?: option->base + option->second_offset; hdr.tags_addr = option->tags_addr ?: option->base + option->tags_offset; if (option->name) { strncpy((char *) hdr.name, option->name, sizeof(hdr.name)); } if (option->cmdline) { bootimg_copy_cmdline(&hdr, option->cmdline); } } images[0].name = option->kernel; images[0].size_addr = &hdr.kernel_size; images[1].name = option->ramdisk; images[1].size_addr = &hdr.ramdisk_size; images[2].name = option->second; images[2].size_addr = &hdr.second_size; image_count = 3; if (option->dt) { images[image_count].name = option->dt; images[image_count++].size_addr = &hdr.dt_size; } for (p = images, p_end = p + image_count; p < p_end; p++) { if (p->name) { println("write image %s", p->name); ret = bootimg_write_image(fd, p->name, p->size_addr, hdr.page_size, &context); if (ret < 0) { pr_red_info("bootimg_write_image"); goto out_close_fd; } } else { *p->size_addr = 0; } cavan_sha_update(&context, p->size_addr, sizeof(unsigned)); } if (option->remain) { println("write remain image %s", option->remain); ret = file_copy3(option->remain, fd); if (ret < 0) { pr_red_info("file_copy3"); goto out_close_fd; } } if (option->check_all) { cavan_sha_update(&context, &hdr.tags_addr, sizeof(hdr.tags_addr)); cavan_sha_update(&context, &hdr.page_size, sizeof(hdr.page_size)); cavan_sha_update(&context, hdr.unused, sizeof(hdr.unused)); cavan_sha_update(&context, hdr.name, sizeof(hdr.name)); cavan_sha_update(&context, hdr.cmdline, sizeof(hdr.cmdline)); if (hdr.extra_cmdline[0]) { cavan_sha_update(&context, hdr.extra_cmdline, sizeof(hdr.extra_cmdline)); } } cavan_sha_finish(&context, (u8 *) hdr.id); bootimg_header_dump(&hdr); ret = ffile_writeto(fd, &hdr, sizeof(hdr), 0); if (ret < 0) { pr_red_info("ffile_writeto"); goto out_close_fd; } pr_green_info("pack %s successfull", option->output); out_close_fd: close(fd); return ret; }
static int write2emmc(int pkg_fd, int img_count, int retry_count, enum swan_image_type *skip_types, size_t skip_img_count) { int ret; int img_fd; u32 tmp_crc32; struct swan_image_info img_info; while (img_count) { int retry; ret = read_image_info(pkg_fd, &img_info); if (ret < 0) { pr_err_info("read_image_info"); return ret; } if (array_has_element(img_info.type, (int *) skip_types, skip_img_count)) { ret = lseek(pkg_fd, img_info.length, SEEK_CUR); if (ret < 0) { pr_err_info("lseek"); return ret; } pr_warn_info("skipping image \"%s\" ...", swan_image_type_tostring(img_info.type)); continue; } img_fd = open_dest_device(&img_info); if (img_fd < 0) { pr_err_info("open_dest_device"); return ret; } retry = retry_count; while (retry--) { off_t pkg_pointer_bak; ret = get_file_pointer(pkg_fd, &pkg_pointer_bak); if (ret < 0) { pr_err_info("can't backup file pointer"); goto out_close_img; } ret = read_simple_image(pkg_fd, img_fd, img_info.length, img_info.offset); if (ret < 0) { pr_err_info("get_image"); goto out_close_img; } ret = lseek(img_fd, img_info.offset, SEEK_SET); if (ret < 0) { pr_err_info("lseek"); goto out_close_img; } fsync(img_fd); println("check image crc32 checksum"); tmp_crc32 = 0; ret = ffile_ncrc32(img_fd, img_info.length, &tmp_crc32); if (ret < 0) { pr_err_info("ffile_ncrc32"); goto out_close_img; } println("img_crc32 = 0x%08x, tmp_crc32 = 0x%08x", img_info.crc32, tmp_crc32); if (img_info.crc32 ^ tmp_crc32) { pr_err_info("image crc32 checksum is not match, retry = %d", retry); } else { pr_green_info("image crc32 checksum is match"); break; } ret = lseek(pkg_fd, pkg_pointer_bak, SEEK_SET); if (ret < 0) { pr_err_info("recovery package file pointer"); goto out_close_img; } } if (retry < 0) { ret = -EIO; goto out_close_img; } close(img_fd); img_count--; } return 0; out_close_img: close(img_fd); return ret; }
static int cavan_xml_document_get_next_token(struct cavan_xml_parser *parser, bool verbose) { char c; int ret; int lineno; char *p, *p_end; char *head, *tail, *value; struct cavan_xml_attribute *attr; parser->prev_token = parser->token; if (parser->next_token != CAVAN_XML_TOKEN_NONE) { parser->token = parser->next_token; parser->next_token = CAVAN_XML_TOKEN_NONE; return 0; } lineno = parser->lineno;; parser->name = NULL; parser->attr = NULL; parser->content = NULL; parser->comment = NULL; parser->token = CAVAN_XML_TOKEN_NONE; p = parser->pos; p_end = parser->pos_end; head = tail = p; while (p < p_end) { switch (*p) { case 0: case '\\': break; case '\n': lineno++; #if CONFIG_CAVAN_XML_DEBUG pr_green_info("lineno = %d", lineno); #endif case ' ': case '\t': case '\f': case '\r': p++; if (parser->token == CAVAN_XML_TOKEN_NONE) { head = p; } else { if (byte_is_space_or_lf(*head)) { head = p; } *tail = 0; } tail = p; break; case '<': if (parser->token != CAVAN_XML_TOKEN_NONE) { if (verbose) { pr_parser_error_info(lineno, "token = %d", parser->token); } ret = -EFAULT; goto out_cavan_xml_token_error; } switch (p[1]) { case '/': p++; parser->token = CAVAN_XML_TOKEN_TAG_END; break; case '?': p++; parser->token = CAVAN_XML_TOKEN_TAG_ATTR; break; case '!': if (text_lhcmp("--", p + 2) == 0) { p += 4; parser->comment = p; ret = cavan_xml_document_parse_comment(&p, p_end); if (ret < 0) { if (verbose) { pr_parser_error_info(lineno, "cavan_xml_document_parse_comment"); } ret = -EFAULT; goto out_cavan_xml_token_error; } parser->token = CAVAN_XML_TOKEN_COMMENT; parser->pos = p + 1; parser->lineno = lineno + ret; return 0; } default: parser->token = CAVAN_XML_TOKEN_TAG_BEGIN; } if (byte_is_named(*++p) == false) { if (verbose) { pr_parser_error_info(lineno, "tag name is empty"); } ret = -EFAULT; goto out_cavan_xml_token_error; } parser->name = p; p = text_skip_name(p, p_end); if (parser->name == p) { if (verbose) { pr_parser_error_info(lineno, "tag name is empty"); } ret = -EFAULT; goto out_cavan_xml_token_error; } head = tail = p; break; case '?': if (parser->token == CAVAN_XML_TOKEN_NONE) { if (verbose) { pr_parser_error_info(lineno, "invalid '?'"); } ret = -EFAULT; goto out_cavan_xml_token_error; } parser->token = CAVAN_XML_TOKEN_TAG_ATTR; goto label_tag_single; case '/': if (parser->token == CAVAN_XML_TOKEN_NONE) { if (verbose) { pr_parser_error_info(lineno, "invalid '/'"); } ret = -EFAULT; goto out_cavan_xml_token_error; } parser->token = CAVAN_XML_TOKEN_TAG_SINGLE; label_tag_single: if (*++p != '>') { if (verbose) { pr_parser_error_info(lineno, "need '>' by has '%c'", *p); } ret = -EFAULT; goto out_cavan_xml_token_error; } goto label_tag_end; case '>': if (parser->token == CAVAN_XML_TOKEN_NONE) { if (verbose) { pr_parser_error_info(lineno, "invalid '>'"); } ret = -EFAULT; goto out_cavan_xml_token_error; } label_tag_end: *tail = 0; if (cavan_xml_tag_is_content(parser->name)) { *tail = '>'; parser->token = CAVAN_XML_TOKEN_COTENT; } else { parser->pos = ++p; parser->lineno = lineno; } return 0; case '=': p = text_skip_space_and_lf(p + 1, p_end); c = *p; if (c != '"' && c != '\'') { if (verbose) { pr_parser_error_info(lineno, "need a '\"' or '"); } ret = -EFAULT; goto out_cavan_xml_token_error; } value = ++p; ret = cavan_xml_attribute_parse_value(c, &p, p_end); if (ret < 0) { if (verbose) { pr_parser_error_info(lineno, "cavan_xml_attribute_parse_value"); } ret = -EFAULT; goto out_cavan_xml_token_error; } lineno += ret; *tail = 0; if (cavan_xml_attribute_set(&parser->attr, head, value, 0) == false) { if (verbose) { pr_parser_error_info(lineno, "cavan_xml_attribute_alloc"); } ret = -EFAULT; goto out_cavan_xml_token_error; } head = tail = ++p; break; default: if (parser->token == CAVAN_XML_TOKEN_NONE) { if (verbose) { pr_parser_error_info(lineno, "invalid content"); } ret = -EFAULT; goto out_cavan_xml_token_error; } tail++, p++; } } ret = 0; parser->token = CAVAN_XML_TOKEN_EOF; out_cavan_xml_token_error: attr = parser->attr; while (attr) { struct cavan_xml_attribute *next = attr->next; cavan_xml_attribute_free(attr); attr = next; } return ret; }
static struct cavan_xml_document *cavan_xml_document_parse_base(char *content, size_t size) { int ret; struct cavan_xml_parser parser; struct general_stack stack; struct cavan_xml_document *doc; struct cavan_xml_tag *tag, *parent, **pparent; ret = general_stack_init_fd(&stack, 10); if (ret < 0) { pr_red_info("general_stack_init_fd"); return NULL; } doc = cavan_xml_document_alloc(); if (doc == NULL) { pr_red_info("cavan_xml_document_alloc"); goto out_general_stack_free; } parser.lineno = 1; parser.pos = content; parser.pos_end = content + size; parser.prev_token = parser.next_token = parser.token = CAVAN_XML_TOKEN_NONE; while (1) { ret = cavan_xml_document_get_next_token(&parser, true); if (ret < 0) { goto out_cavan_xml_document_free; } #if CONFIG_CAVAN_XML_DEBUG pr_green_info("token = %d", parser.token); #endif switch (parser.token) { case CAVAN_XML_TOKEN_COMMENT: case CAVAN_XML_TOKEN_NONE: break; case CAVAN_XML_TOKEN_EOF: goto out_parse_complete; case CAVAN_XML_TOKEN_TAG_ATTR: tag = cavan_xml_tag_create(&doc->attr, parser.name, CAVAN_XML_FLAG_UNIQUE); if (tag == NULL) { pr_red_info("cavan_xml_tag_create"); goto out_cavan_xml_document_free; } cavan_xml_attribute_extend(&tag->attr, parser.attr); break; case CAVAN_XML_TOKEN_TAG_BEGIN: case CAVAN_XML_TOKEN_TAG_SINGLE: parent = general_stack_get_top_fd(&stack); if (parent) { if (parent->content) { pr_parser_error_info(parser.lineno, "tag %s has content %s", parent->name, parent->content); goto out_cavan_xml_document_free; } pparent = &parent->child; } else { pparent = &doc->tag; } tag = cavan_xml_tag_create(pparent, parser.name, 0); if (tag == NULL) { pr_red_info("cavan_xml_tag_alloc"); goto out_cavan_xml_document_free; } cavan_xml_attribute_extend(&tag->attr, parser.attr); if (parser.token == CAVAN_XML_TOKEN_TAG_BEGIN) { ret = cavan_xml_document_get_next_token(&parser, false); if (ret < 0 || parser.token == CAVAN_XML_TOKEN_COTENT) { int lineno; size_t length; char *pos, *p; char buff[512]; pos = parser.pos; length = snprintf(buff, sizeof(buff), "</%s>", tag->name); p = mem_kmp_find(pos, buff, parser.pos_end - pos, length); if (p == NULL) { pr_parser_error_info(parser.lineno, "tag %s is not pair", tag->name); goto out_cavan_xml_document_free; } *p = 0; for (lineno = 0; pos < p; pos++) { if (*pos == '\n') { lineno++; } } if (lineno) { tag->flags |= CAVAN_XML_FLAG_CONTENT_MULTI_LINE; parser.lineno += lineno; } cavan_xml_tag_set_content(tag, parser.pos, 0); parser.pos = p + length; } else { general_stack_push_fd(&stack, tag); parser.next_token = parser.token; } } break; case CAVAN_XML_TOKEN_TAG_END: tag = general_stack_pop_fd(&stack); if (tag == NULL || strcmp(parser.name, tag->name)) { pr_parser_error_info(parser.lineno, "tag (%s <> %s) is not pair", tag ? tag->name : "null", parser.name); goto out_cavan_xml_document_free; } break; default: pr_red_info("unknown token %d", parser.token); goto out_cavan_xml_document_free; } } out_parse_complete: if (general_stack_get_top_fd(&stack)) { pr_red_info("tag stack not empty"); goto out_cavan_xml_document_free; } doc->content = content; general_stack_free(&stack); return doc; out_cavan_xml_document_free: cavan_xml_document_free(doc); out_general_stack_free: general_stack_free(&stack); return NULL; }
static int cy8c242_firmware_write_data(struct cavan_input_chip *chip, struct cavan_firmware *fw) { int ret; u32 delay; u8 datas[32]; ssize_t rdlen; char buff[512], *line, *line_end; pr_pos_info(); while (1) { rdlen = cavan_firmware_read_line(fw, buff, sizeof(buff), 0, 5000); if (rdlen < 0) { pr_red_info("cavan_firmware_read_line"); return rdlen; } if (rdlen == 0) { pr_green_info("Firmware upgrade successfully"); break; } for (line = buff, line_end = line + rdlen; line < line_end && BYTE_IS_SPACE(*line); line++); if (line_end - line == 0) { continue; } switch (line[0]) { case 'w': case 'W': ret = cy8c242_firmware2data(line + 2, line_end, datas); ret = chip->master_send(chip, datas + 1, ret - 1); if (ret < 0) { pr_red_info("master_send"); return ret; } break; case 'r': case 'R': ret = chip->master_recv(chip, datas, 3); if (ret < 0) { pr_red_info("master_recv"); return ret; } if (datas[2] != 0x20) { pr_red_info("datas[2] = 0x%02x", datas[2]); return -EFAULT; } break; case '[': ret = sscanf(line, "[delay=%d]", &delay); if (ret == 1) { msleep(delay); } else { pr_bold_info("unknown delay"); } break; case '#': pr_green_info("Comment Line"); break; default: pr_red_info("unknown char 0x%02x at line %s", line[0], line); } } return 0; }
static int ftp_client_receive_file(struct network_client *client, const char *ip, u16 port) { int ret; int sockfd, data_sockfd; ssize_t rdlen; char buff[1024], *p; struct sockaddr_in addr; socklen_t addrlen; sockfd = inet_create_tcp_service(port); if (sockfd < 0) { pr_red_info("inet_create_tcp_service"); return sockfd; } p = text_copy(buff, "PORT "); p = text_replace_char2(ip, p, '.', ','); p += sprintf(p, ",%d,%d\r\n", port >> 8, port & 0xFF); rdlen = ftp_client_send_command(client, buff, p - buff, buff, sizeof(buff)); if (rdlen < 0) { pr_red_info("ftp_client_send_command"); return rdlen; } rdlen = ftp_client_send_command(client, "LIST\r\n", 0, buff, sizeof(buff)); if (rdlen < 0) { pr_red_info("ftp_client_send_command"); return rdlen; } data_sockfd = inet_accept(sockfd, &addr, &addrlen); if (data_sockfd < 0) { pr_red_info("inet_accept"); ret = data_sockfd; goto out_close_sockfd; } while (1) { rdlen = inet_recv(data_sockfd, buff, sizeof(buff)); if (rdlen < 0) { pr_red_info("inet_recv"); ret = rdlen; goto out_close_data_link; } if (rdlen == 0) { pr_green_info("data receive complete"); break; } #if FTP_DEBUG print_ntext(buff, rdlen); #endif } ret = 0; out_close_data_link: shutdown(data_sockfd, SHUT_RDWR); inet_close_tcp_socket(data_sockfd); out_close_sockfd: inet_close_tcp_socket(sockfd); return ret; }
static int __devinit HC548_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct HC548_touchscreen_data *data; struct input_dev *input_dev; u8 buf,buf1; int error; #ifdef ENABLE_UPGRADE int times = 0; #endif pr_pos_info(); data = kzalloc(sizeof(struct HC548_touchscreen_data), GFP_KERNEL); if(data == NULL) { pr_red_info("HC548 kzalloc touchscreen_data failed!\n"); error = -ENOMEM; goto exit_alloc_data_failed; } input_dev = input_allocate_device(); if(input_dev == NULL) { pr_red_info("HC548 input allocate device failed!\n"); error = -ENOMEM; goto exit_input_dev_alloc_failed; } data->input_dev = input_dev; input_set_drvdata(input_dev, data); input_dev->name = HC5XX_NAME; input_dev->id.bustype = BUS_I2C; input_dev->dev.parent = &client->dev; input_dev->open = HC548_input_open; input_dev->close = HC548_input_close; input_dev->evbit[0] = BIT_MASK(EV_SYN) | BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS) ; // input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH); input_dev->propbit[0] = BIT(INPUT_PROP_DIRECT); input_dev->absbit[0] = BIT_MASK(ABS_MT_TRACKING_ID) | BIT_MASK(ABS_MT_POSITION_X) | BIT_MASK(ABS_MT_POSITION_Y)| BIT_MASK(ABS_MT_TOUCH_MAJOR);// | BIT_MASK(ABS_MT_WIDTH_MAJOR); input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0, HC548_MAX_X, 0 , 0); input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0, HC548_MAX_Y, 0 , 0); input_set_abs_params(input_dev,ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0); // input_set_abs_params(input_dev,ABS_MT_WIDTH_MAJOR, 0, 200, 0, 0); input_set_abs_params(input_dev, ABS_MT_TRACKING_ID, 0, 5, 0, 0); #ifdef KEY_MAP_INIT HC548_key_map_init(input_dev); #endif error = input_register_device(input_dev); if(error < 0) { pr_red_info("HC548 input_register_device failed!\n"); goto err_unregister_device; } data->ts_wq = create_singlethread_workqueue("kworkqueue_ts"); if (!data->ts_wq) { dev_err(&client->dev, "Could not create workqueue\n"); goto error_wq_create; } flush_workqueue(data->ts_wq); INIT_WORK(&data->work, HC548_poscheck); data->client = client; i2c_set_clientdata(client,data); this_client = client; /* configure rest pin */ #if 0 data->reset = RK30_PIN0_PB6;//RK2928_PIN1_PB1; //INVALID_GPIO;//S5PV210_GPH2(5); if (data->reset != INVALID_GPIO) { error = gpio_request(data->reset, NULL); if (error < 0) { pr_red_info("Unable to request GPIO pin %d to act as reset\n",data->reset); goto exit_rst_gpio_request_failed; } } HC548_hard_reset(data); #endif hc_register_read(0x00, &buf, 1); if(buf == 0x86) pr_green_info("HC548: I2C communication is OK, TP chip ID is %x\n",buf); else pr_red_info("HC548: I2C ERROR!! TP chip ID is %x\n",buf); #ifdef ENABLE_UPGRADE pr_green_info("HC548: HC548_fw_data[0] is %x\n",HC548_fw_data[0]); if(HC548_fw_data[0] == 0xff) //debug_control,if data is 0xff,TP drive always upgrade { while(1) { int ret = 0; ret = HC548_upgrade(client); if(ret < 0) { times ++; printk("times = %d\n",times); } else { times = 0; break; } if(times >= 10) break; } } else { __u8 buf; //i2c_smbus_read_i2c_block_data(client,0x75,1,&buf); hc_register_read(0x75, &buf, 1); hc_register_read(0x73, &buf1, 1); if((buf < HC548_fw_data[0]) || ((buf == HC548_fw_data[0]) && (buf1 < HC548_fw_data[1]))) // if(buf < HC548_fw_data[0]) { while(1) { int ret = 0; ret = HC548_upgrade(client); if(ret < 0) { times ++; printk("times = %d\n",times); } else { times = 0; break; } if(times >= 10) break; } } } printk("====CTP download times = %d\n",times); #endif /* configure interrupt pin */ #if 0 data->irq = RK30_PIN1_PB7;//RK2928_PIN1_PB3;//RK2928_PIN1_PB0; //S5PV210_GPH2(4); error = gpio_request(data->irq, "touch_irq_key"); if (error < 0) { pr_red_info("Unable to request GPIO pin %d. error %d.\n", data->irq, error); goto exit_irq_gpio_request_failed; } error = gpio_direction_input(data->irq); if (error < 0) { pr_red_info("Failed to configure input direction for GPIO %d, error %d\n", data->irq, error); goto err_free_irq_gpio; } #endif client->irq = IRQ_PORT;//gpio_to_irq(data->irq); if (client->irq < 0) { error = client->irq; pr_red_info( "Unable to get irq number for GPIO %d, error %d\n", data->irq, error); goto err_free_irq; } // error = request_threaded_irq(client->irq, NULL, HC548_interrupt, IRQF_TRIGGER_RISING, client->dev.driver->name, data); error = request_threaded_irq(client->irq, NULL, HC548_interrupt, IRQF_TRIGGER_FALLING, client->dev.driver->name, data); if(error) { pr_red_info("HC548 failed to register irq!\n"); goto exit_irq_request_failed; } #ifdef CONFIG_HC8600_SLEEP_KEEP_POWER INIT_WORK(&data->resume_work, ts_work_resume); #endif pr_green_info("HC548_probe ok!\n"); return 0; exit_irq_request_failed: cancel_work_sync(&data->work); err_free_irq: free_irq(client->irq, data); //err_free_irq_gpio: // if (data->irq) // gpio_free(data->irq); //exit_irq_gpio_request_failed: // HC548_hard_reset(data); // if (data->reset) // gpio_free(data->reset); exit_rst_gpio_request_failed: destroy_workqueue(data->ts_wq); i2c_set_clientdata(client,NULL); this_client = NULL; error_wq_create: input_unregister_device(input_dev); err_unregister_device: input_free_device(input_dev); exit_input_dev_alloc_failed: kfree(data); exit_alloc_data_failed: return error; }
int hua_ts_device_probe(struct hua_input_device *dev) { int ret; struct hua_ts_device *ts = (struct hua_ts_device *) dev; struct hua_input_chip *chip = dev->chip; struct hua_input_core *core = chip->core; struct input_dev *input = dev->input; const struct hua_ts_touch_key *key, *key_end; const char *name; ret = hua_input_add_kobject(&core->prop_kobj, "board_properties"); if (ret < 0 && ret != -EEXIST) { pr_red_info("hua_input_add_kobject"); return ret; } name = kasprintf(GFP_KERNEL, "virtualkeys.%s", input->name); if (name == NULL) { ret = -ENOMEM; pr_red_info("kasprintf"); goto out_hua_input_remove_kobject; } hua_ts_board_properties_attr.attr.name = name; ret = hua_input_create_sysfs_files(dev, &core->prop_kobj, &hua_ts_board_properties_attr, 1); if (ret < 0) { pr_red_info("hua_input_add_kobject"); goto out_kfree_name; } ret = sysfs_create_files(&dev->misc_dev.dev->kobj, hua_ts_device_attributes); if (ret < 0) { pr_red_info("sysfs_create_files"); goto out_hua_input_remove_sysfs_files; } #ifdef CONFIG_HAS_EARLYSUSPEND ts->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1; ts->early_suspend.suspend = hua_ts_suspend; ts->early_suspend.resume = hua_ts_resume; register_early_suspend(&ts->early_suspend); #elif defined(CONFIG_FB) && defined(CONFIG_HUAMOBILE_USE_FB_NOTIFILER) ts->fb_notifier.notifier_call = hua_ts_fb_notifier_call; ret = fb_register_client(&ts->fb_notifier); if (ret < 0) { pr_red_info("fb_register_client"); } #else ts->pm_notifier.notifier_call = hua_ts_pm_notifier_call; ret = register_pm_notifier(&ts->pm_notifier); if (ret < 0) { pr_red_info("register_pm_notifier"); } #endif set_bit(INPUT_PROP_DIRECT, input->propbit); set_bit(EV_KEY, input->evbit); set_bit(BTN_TOUCH, input->keybit); if (ts->keys && ts->key_count) { for (key = ts->keys, key_end = key + ts->key_count; key < key_end; key++) { set_bit(key->code, input->keybit); } } set_bit(EV_ABS, input->evbit); input_set_abs_params(input, ABS_MT_POSITION_X, ts->xmin, ts->xmax, dev->fuzz, dev->flat); input_set_abs_params(input, ABS_MT_POSITION_Y, ts->ymin, ts->ymax, 0, 0); input_set_abs_params(input, ABS_MT_TRACKING_ID, 0, ts->point_count - 1, 0, 0); input->open = hua_ts_device_open; dev->remove = hua_ts_device_remove; ts->touch_count = 0; pr_green_info("huamobile touch screen %s probe complete", dev->name); return 0; out_hua_input_remove_sysfs_files: hua_input_remove_sysfs_files(&core->prop_kobj, &hua_ts_board_properties_attr, 1); out_kfree_name: kfree(name); out_hua_input_remove_kobject: hua_input_remove_kobject(&core->prop_kobj); return ret; }