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 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 hua_ts_device_open(struct input_dev *dev)
{
int ret;
struct hua_input_device *idev = input_get_drvdata(dev);
pr_pos_info();
ret = hua_input_device_set_enable_lock(idev, true);
if (ret < 0)
{
pr_red_info("hua_input_device_set_enable_lock");
return ret;
}
return 0;
}
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;
}
void cavan_lock_release(struct cavan_lock *lock)
{
pthread_t owner = pthread_self();
if (!pthread_equal(owner, lock->owner) || --lock->held_count > 0) {
return;
}
if (lock->held_count < 0) {
pr_red_info("unbalanced %s %d", __FUNCTION__, lock->held_count);
lock->held_count = 0;
}
lock->owner = 0;
pthread_mutex_unlock(&lock->mutex);
}
int swan_ts_open_misc_device(const char *devpath, int flags)
{
int fd;
if (devpath) {
fd = try_to_open(flags, devpath, SWAN_TS_MISC_DEVICE, SWAN_TS_PROC_DEVICE, NULL);
} else {
fd = try_to_open(flags, SWAN_TS_MISC_DEVICE, SWAN_TS_PROC_DEVICE, NULL);
}
if (fd < 0) {
pr_red_info("Open misc device failed");
}
return fd;
}
static int cy8c242_proximity_event_handler(struct cavan_input_chip *chip, struct cavan_input_device *dev)
{
int ret;
u8 value;
ret = chip->read_register(chip, 0x13, &value);
if (ret < 0) {
pr_red_info("dev->read_register");
cavan_input_chip_recovery(chip, false);
return ret;
}
cavan_sensor_report_value(dev->input, value == 0);
return 0;
}
void cavan_thread_stop(struct cavan_thread *thread)
{
int i;
pthread_mutex_lock(&thread->lock);
for (i = 1; i < 50; i++) {
switch (thread->state) {
case CAVAN_THREAD_STATE_STOPPPING:
break;
case CAVAN_THREAD_STATE_WAIT_EVENT:
cavan_thread_send_event(thread, 0);
thread->state = CAVAN_THREAD_STATE_STOPPPING;
break;
case CAVAN_THREAD_STATE_SLEEP:
case CAVAN_THREAD_STATE_SUSPEND:
case CAVAN_THREAD_STATE_RUNNING:
thread->state = CAVAN_THREAD_STATE_STOPPPING;
break;
default:
thread->state = CAVAN_THREAD_STATE_STOPPED;
goto out_pthread_mutex_unlock;
}
pthread_cond_broadcast(&thread->cond);
pthread_mutex_unlock(&thread->lock);
thread->wake_handker(thread, thread->private_data);
msleep(i);
pthread_mutex_lock(&thread->lock);
}
if (thread->state != CAVAN_THREAD_STATE_STOPPED) {
#if CAVAN_THREAD_DEBUG
pr_red_info("stop timeout kill it now");
#endif
pthread_kill(thread->id, SIGUSR1);
}
thread->state = CAVAN_THREAD_STATE_STOPPED;
out_pthread_mutex_unlock:
pthread_mutex_unlock(&thread->lock);
}
static int bl86x8_ts_event_handler(struct hua_input_chip *chip, struct hua_input_device *dev)
{
int ret;
int count;
struct input_dev *input = dev->input;
struct bl86x8_data_package package;
struct bl86x8_touch_point *p, *p_end;
struct hua_ts_device *ts = (struct hua_ts_device *)dev;
ret = bl86x8_read_data_package(chip, &package);
if (ret < 0)
{
pr_red_info("bl86x8_read_data_package");
hua_input_chip_recovery(chip, false);
return ret;
}
count = package.td_status & 0x07;
if (count == 0)
{
if (ts->touch_count)
{
hua_ts_mt_touch_release(input);
ts->touch_count = 0;
}
return 0;
}
if (unlikely(count > BL86X8_POINT_COUNT))
{
// pr_red_info("Too much points = %d", count);
count = BL86X8_POINT_COUNT;
}
for (p = package.points, p_end = p + count; p < p_end; p++)
{
hua_ts_report_mt_data(input, BL86X8_BUILD_AXIS(p->xh, p->xl), \
BL86X8_BUILD_AXIS(p->yh, p->yl));
}
input_sync(input);
ts->touch_count = count;
return 0;
}
static int ftp_server_receive_file1(struct network_client *client, const struct network_url *url, int fd)
{
int ret;
ret = ftp_create_data_link(client, url);
if (ret < 0)
{
pr_red_info("ftp_create_data_link");
return ret;
}
ret = network_client_recv_file(client, fd, 0);
network_client_close(client);
return ret;
}
static int cy8c242_readid(struct cavan_input_chip *chip)
{
int ret;
char buff[18];
pr_pos_info();
ret = chip->read_data(chip, 0x00, buff, sizeof(buff));
if (ret < 0) {
pr_red_info("cavan_i2c_read_data");
return ret;
}
cavan_input_print_memory(buff, ret);
return 0;
}
static int bl86x8_readid(struct hua_input_chip *chip)
{
int ret;
struct bl86x8_data_package package;
pr_pos_info();
ret = bl86x8_read_data_package(chip, &package);
if (ret < 0)
{
pr_red_info("huamobile_i2c_read_data");
return ret;
}
hua_input_print_memory(&package, sizeof(package));
return 0;
}
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;
}
int cavan_input_add_kobject(struct kobject *kobj, const char *name)
{
int ret;
if (kobj->state_initialized == 0)
{
kobject_init(kobj, &cavan_input_kobj_type);
}
ret = kobject_add(kobj, NULL, name);
if (ret < 0)
{
pr_red_info("kobject_add");
return ret;
}
return 0;
}
ssize_t parse_config_file2(const char *pathname, char sep, int (*handler)(char *key, char *value, void *data), void *data)
{
ssize_t ret;
size_t size;
char *content;
content = file_read_all_text(pathname, &size);
if (content == NULL)
{
pr_red_info("file_read_all_text");
return -EFAULT;
}
ret = parse_config_file(content, size, sep, handler, data);
free(content);
return ret;
}
static int huamobile_mouse_probe(struct huamobile_input_device *dev, void *data)
{
struct huamobile_input_service *service = data;
struct huamobile_mouse_device *mouse = (struct huamobile_mouse_device *)dev;
pr_pos_info();
if (service->lcd_width <= 0 || service->lcd_height <= 0)
{
pr_red_info("service->lcd_width <= 0 || service->lcd_height <= 0");
return -EINVAL;
}
mouse->xmax = service->lcd_width - 1;
mouse->ymax = service->lcd_height - 1;
return 0;
}
void *cftp_service_heandle(void *data)
{
struct cftp_descriptor *desc = data;
union cftp_message *msg;
ssize_t recvlen;
size_t max_xfer_length;
max_xfer_length = desc->max_xfer_length;
msg = malloc(max_xfer_length);
if (msg == NULL) {
pr_err_info("malloc");
return NULL;
}
while (1) {
recvlen = cftp_receive_data(desc, msg, max_xfer_length);
if (recvlen < 0) {
pr_err_info("cftp_receive_data");
break;
}
switch (msg->type) {
case CFTP_PACKAGE_FILE_READ:
cftp_send_handle(desc, (struct cftp_file_request *) msg);
break;
case CFTP_PACKAGE_FILE_WRITE:
cftp_receive_handle(desc, (struct cftp_file_request *) msg);
break;
case CFTP_PACKAGE_COMMAND:
cftp_command_handle(desc, (struct cftp_command_request *) msg);
break;
default:
pr_red_info("invalid request %d", msg->type);
}
}
free(msg);
return NULL;
}
static int bootimg_parse_config_handler(char *key, char *value, void *data)
{
struct bootimg_header *hdr = data;
if (strcmp(key, "kernel_addr") == 0)
{
hdr->kernel_addr = text2value_unsigned(value, NULL, 16);
}
else if (strcmp(key, "ramdisk_addr") == 0)
{
hdr->ramdisk_addr = text2value_unsigned(value, NULL, 16);
}
else if (strcmp(key, "second_addr") == 0)
{
hdr->second_addr = text2value_unsigned(value, NULL, 16);
}
else if (strcmp(key, "tags_addr") == 0)
{
hdr->tags_addr = text2value_unsigned(value, NULL, 16);
}
else if (strcmp(key, "page_size") == 0)
{
hdr->page_size = text2value_unsigned(value, NULL, 10);
}
else if (strcmp(key, "unused") == 0)
{
text2array(value, hdr->unused, 2, ',');
}
else if (strcmp(key, "board") == 0)
{
strncpy((char *) hdr->name, value, sizeof(hdr->name));
}
else if (strcmp(key, "cmdline") == 0)
{
bootimg_copy_cmdline(hdr, value);
}
else
{
pr_red_info("unknown key %s", key);
return -EINVAL;
}
return 1;
}
static int app_network_client_main(int argc, char *argv[])
{
int ret;
struct network_client client;
assert(argc > 1);
ret = network_client_open2(&client, argv[1], CAVAN_NET_FLAG_WAIT);
if (ret < 0) {
pr_red_info("network_client_open2");
return ret;
}
ret = app_network_cmdline(&client);
network_client_close(&client);
return ret;
}
int cavan_mux_append_receive_package(struct cavan_mux *mux, struct cavan_mux_package *package)
{
int ret;
struct cavan_mux_link *link;
cavan_lock_acquire(&mux->lock);
link = cavan_mux_find_link(mux, package->dest_port);
if (link == NULL) {
pr_red_info("invalid port %d", package->dest_port);
ret = -EINVAL;
} else {
ret = cavan_mux_link_append_receive_package(link, package);;
}
cavan_lock_release(&mux->lock);
return ret;
}
static int cavan_mux_send_thread_handler(struct cavan_thread *thread, void *data)
{
struct cavan_mux *mux = data;
struct cavan_mux_package_raw *package_raw;
package_raw = mux->package_head;
if (package_raw == NULL)
{
cavan_thread_suspend(thread);
}
else
{
struct cavan_mux_package *package = &package_raw->package;
char *data = (char *) package;
size_t length = cavan_mux_package_get_whole_length(package);
while (length)
{
ssize_t wrlen;
wrlen = mux->send(mux, data, length);
if (wrlen < 0)
{
pr_red_info("mux->send");
return wrlen;
}
data += wrlen;
length -= wrlen;
}
mux->package_head = package_raw->next;
if (mux->package_head == NULL)
{
mux->package_tail = &mux->package_head;
}
cavan_mux_package_free(mux, package);
}
return 0;
}
char *math_text2memory(const char *text, byte *mem, size_t mem_size, int base)
{
int value;
bool negative;
while (BYTE_IS_SPACE(*text)) {
text++;
}
if (*text == '-') {
negative = true;
text++;
} else {
negative = false;
}
mem_set(mem, 0, mem_size);
base = prefix2base2(text, &text, base);
if (base < 0) {
pr_red_info("prefix2base");
return (char *) text;
}
while (1) {
value = char2value(*text);
if (value < 0 || value >= base) {
break;
}
math_memory_mul_single(mem, mem_size, base, NULL, 0);
math_memory_add_single(mem, mem_size, value, NULL, 0);
text++;
}
if (negative) {
math_memory_complement(mem, mem_size, NULL, 0);
}
return (char *) text;
}
int swan_ts_input_calibration(const char *devname)
{
ssize_t count;
struct cavan_event_matcher matcher = {
.match = swan_ts_match,
.handler = swan_ts_match_handler
};
if (devname == NULL) {
devname = SWAN_TS_DEVICE_NAME;
}
count = cavan_event_scan_devices(&matcher, (void *) devname);
if (count <= 0) {
pr_red_info("cavan_event_scan_devices");
return -EFAULT;
}
return 0;
}
struct cavan_cache *cavan_cache_create(size_t size)
{
struct cavan_cache *cache;
cache = malloc(sizeof(struct cavan_cache) + size);
if (cache == NULL)
{
pr_error_info("malloc");
return NULL;
}
if (cavan_cache_init(cache, (void *) (cache + 1), size) < 0)
{
pr_red_info("cavan_cache_init");
free(cache);
return NULL;
}
return cache;
}
int main(int argc, char *argv[])
{
int i;
int fd;
int ret;
pid_t pid;
if (argc < 2)
{
println("Usage: %s [command] <options ...>", argv[0]);
return -EINVAL;
}
fd = cavan_exec_redirect_stdio_popen(argv[1], 0xFFFF, 0xFFFFF, &pid, 0x01);
if (fd < 0)
{
pr_red_info("cavan_exec_redirect_stdio_popen");
return fd;
}
for (i = 2; i < argc; i++)
{
ret = write(fd, argv[i], strlen(argv[i]));
if (ret < 0)
{
goto out_close_fd;
}
ret = write(fd, "\n", 1);
if (ret < 0)
{
goto out_close_fd;
}
}
ret = cavan_exec_waitpid(pid);
out_close_fd:
close(fd);
return ret;
}
int main(int argc, char *argv[])
{
int ret;
struct huamobile_input_service service =
{
.event_service =
{
.matcher = huamobile_vk_matcher
},
.lcd_width = 100,
.lcd_height = 100,
.mouse_speed = 1.5,
.gsensor_handler = NULL,
.touch_handler = NULL,
.move_handler = NULL,
.release_handler = NULL,
.key_handler = NULL
};
ret = huamobile_input_service_start(&service, NULL);
if (ret < 0)
{
pr_red_info("huamobile_ts_start");
return ret;
}
#if 1
ret = huamobile_event_service_join(&service.event_service);
if (ret < 0)
{
pr_error_info("huamobile_input_thread_join");
}
#else
huamobile_ssleep(10);
#endif
huamobile_input_service_stop(&service);
return ret;
}
ssize_t cavan_cache_read_line(struct cavan_cache *cache, char *buff, size_t size, size_t reserved, u32 timeout)
{
char *buff_bak = buff;
char *buff_end = buff + size - 1;
while (buff < buff_end)
{
char c;
ssize_t rdlen;
rdlen = cavan_cache_read(cache, &c, 1, reserved, timeout);
if (rdlen < 0)
{
pr_red_info("cavan_cache_read");
return rdlen;
}
if (rdlen == 0)
{
break;
}
switch (c)
{
case '\n':
if (buff > buff_bak)
{
goto out_return;
}
case '\r':
break;
default:
*buff++ = c;
}
}
out_return:
*buff = 0;
return buff - buff_bak;
}
static int ftp_data_service_open(struct network_service *service, struct network_client *client, char *buff, size_t size)
{
u8 *ip;
int ret;
u16 port;
struct in_addr addr;
struct network_url url;
network_url_init(&url, "tcp", "any", 0, NULL);
ret = network_service_open(service, &url, 0);
if (ret < 0)
{
pr_red_info("network_service_open");
return ret;
}
ret = network_service_get_local_port(service);
if (ret < 0)
{
pr_error_info("network_service_get_local_port");
goto out_network_service_close;
}
port = ret;
ret = network_client_get_local_ip(client, &addr);
if (ret < 0)
{
pr_error_info("network_client_getsockname");
goto out_network_service_close;
}
ip = (u8 *) &addr;
return snprintf(buff, size, "227 Entering Passive Mode (%d,%d,%d,%d,%d,%d).\r\n", ip[0], ip[1], ip[2], ip[3], port & 0xFF, (port >> 8) & 0xFF);
out_network_service_close:
network_service_close(service);
return ret;
}
void cavan_thread_suspend(struct cavan_thread *thread)
{
pthread_mutex_lock(&thread->lock);
switch (thread->state) {
case CAVAN_THREAD_STATE_WAIT_EVENT:
case CAVAN_THREAD_STATE_RUNNING:
case CAVAN_THREAD_STATE_SLEEP:
thread->state = CAVAN_THREAD_STATE_SUSPEND;
case CAVAN_THREAD_STATE_SUSPEND:
case CAVAN_THREAD_STATE_STOPPPING:
case CAVAN_THREAD_STATE_STOPPED:
break;
default:
pr_red_info("Invalid state %d", thread->state);
break;
}
pthread_mutex_unlock(&thread->lock);
}
int cavan_thread_start(struct cavan_thread *thread)
{
int ret;
pthread_mutex_lock(&thread->lock);
if (thread->state == CAVAN_THREAD_STATE_NONE) {
ret = cavan_pthread_create(&thread->id, cavan_thread_main_loop, thread, true);
if (ret < 0) {
pr_red_info("cavan_pthread_create: %d", ret);
} else {
thread->state = CAVAN_THREAD_STATE_IDLE;
}
} else {
ret = 0;
}
pthread_mutex_unlock(&thread->lock);
return ret;
}
