Ejemplo n.º 1
0
int main(int argc, char *argv[])
{
	int ret;
	struct cavan_cache *cache;
	pthread_t rdthread;

	cache = cavan_cache_create(10);
	if (cache == NULL) {
		pr_red_info("cavan_cache_create");
		return -1;
	}

	cavan_cache_open(cache);

	cavan_pthread_create(&rdthread, read_thread_handler, cache, true);

	while (1) {
		ssize_t wrlen;
		char buff[1024];

		ret = scanf("%s", buff);
		if (ret != 1 || strcmp(buff, "exit") == 0) {
			break;
		}

		wrlen = cavan_cache_write(cache, buff, strlen(buff));
		if (wrlen < 0) {
			pr_red_info("cavan_cache_write");
			break;
		}

		wrlen = cavan_cache_write(cache, "\n", 1);
		if (wrlen < 0) {
			pr_red_info("cavan_cache_write");
			break;
		}
	}

	cavan_cache_close(cache);

	pr_pos_info();
	pthread_join(rdthread, NULL);

	pr_pos_info();
	cavan_cache_destroy(cache);

	pr_pos_info();
	msleep(1000);
	pr_pos_info();

	return 0;
}
Ejemplo n.º 2
0
static void __exit swan_virtual_keypad_exit(void)
{
	pr_pos_info();

	platform_device_unregister(&swan_virtual_keypad_device);
	platform_driver_unregister(&swan_virtual_keypad_driver);
}
Ejemplo n.º 3
0
int HC548_attach_adapter(void)
{
    struct i2c_board_info info;
    struct i2c_client *client;
    struct i2c_adapter *adapter;
    int ret1;

    pr_pos_info();

    adapter = i2c_get_adapter(I2C_BUS_NUM);
    if(adapter == NULL)
    {
        pr_red_info("HC548 I2C get adapter %d failed\n", I2C_BUS_NUM);
        ret1 = -ENODEV;
        goto out_exit;
    }

    memset(&info, 0, sizeof(struct i2c_board_info));
    strlcpy(info.type, "HC548", I2C_NAME_SIZE);
    info.addr = HC548_SLAVE_ADDR;
    client = i2c_new_device(adapter, &info);
    if(client == NULL)
    {
        pr_red_info("HC548 I2C new device failed\n");
        ret1 = -ENODEV;
        goto out_put_adapter;
    }
    return 0;

out_put_adapter:
    i2c_put_adapter(adapter);
out_exit:
    return ret1;

}
Ejemplo n.º 4
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;
}
Ejemplo n.º 5
0
static void __exit tcp_keypad_exit(void)
{
	pr_pos_info();

	platform_device_unregister(&tcp_keypad_device);
	platform_driver_unregister(&tcp_keypad_driver);
}
Ejemplo n.º 6
0
struct huamobile_input_device *huamobile_mouse_create(void)
{
	struct huamobile_mouse_device *mouse;
	struct huamobile_input_device *dev;
	struct huamobile_touch_point *point;

	pr_pos_info();

	mouse = malloc(sizeof(*mouse));
	if (mouse == NULL)
	{
		pr_error_info("malloc");
		return NULL;
	}

	mouse->xold = 0;
	mouse->yold = 0;

	point = &mouse->point;
	point->id = 0;
	point->x = 0;
	point->y = 0;
	point->pressure = 0;
	point->released = 1;

	dev = &mouse->input_dev;
	dev->probe = huamobile_mouse_probe;
	dev->remove = NULL;
	dev->event_handler = huamobile_mouse_event_handler;

	return dev;
}
Ejemplo n.º 7
0
static int cy8c242_firmware_upgrade(struct cavan_input_chip *chip, struct cavan_firmware *fw)
{
    int ret;

    pr_pos_info();

    ret = cy8c242_enter_upgrade_mode(chip, 10);
    if (ret < 0) {
        pr_red_info("cy8c242_enter_upgrade_mode");
        return ret;
    }

    ret = cy8c242_firmware_write_data(chip, fw);
    if (ret < 0) {
        pr_red_info("cy8c242_firmware_write_data");
        return ret;
    }

    ret = cy8c242_exit_upgrade_mode(chip, 10);
    if (ret < 0) {
        pr_red_info("cy8c242_exit_upgrade_mode");
        return ret;
    }

    cy8c242_readid(chip);

    return 0;
}
Ejemplo n.º 8
0
struct huamobile_input_device *huamobile_single_touch_device_create(void)
{
	struct huamobile_single_touch_device *ts;
	struct huamobile_touch_device *touch_dev;
	struct huamobile_input_device *dev;

	pr_pos_info();

	ts = malloc(sizeof(*ts));
	if (ts == NULL)
	{
		pr_error_info("malloc");
		return NULL;
	}

	ts->pressed = 0;
	ts->point.released = 1;

	touch_dev = &ts->touch_dev;
	touch_dev->xaxis = ABS_X;
	touch_dev->yaxis = ABS_Y;

	dev = &touch_dev->input_dev;
	dev->probe = huamobile_single_touch_device_probe;
	dev->remove = NULL;
	dev->event_handler = huamobile_single_touch_event_handler;

	return dev;
}
Ejemplo n.º 9
0
static int __init tcp_keypad_init(void)
{
	int ret;

	pr_pos_info();

	ret = platform_device_register(&tcp_keypad_device);
	if (ret < 0) {
		pr_red_info("platform_device_register");
		return ret;
	}

	ret = platform_driver_register(&tcp_keypad_driver);
	if (ret < 0) {
		pr_red_info("platform_driver_register");
		goto out_unregister_device;
	}

	return 0;

out_unregister_device:
	platform_device_unregister(&tcp_keypad_device);

	return ret;
}
Ejemplo n.º 10
0
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);
}
Ejemplo n.º 11
0
struct huamobile_input_device *huamobile_multi_touch_device_create(void)
{
	struct huamobile_multi_touch_device *ts;
	struct huamobile_touch_device *touch_dev;
	struct huamobile_input_device *dev;
	struct huamobile_touch_point *p, *p_end;

	pr_pos_info();

	ts = malloc(sizeof(*ts));
	if (ts == NULL) {
		pr_error_info("malloc");
		return NULL;
	}

	ts->point_count = 0;
	ts->point_count_old = 0;

	for (p = ts->points, p_end = p + NELEM(ts->points); p < p_end; p++) {
		p->id = p - ts->points;
		p->pressure = -1;
		p->released = 1;
	}

	touch_dev = &ts->touch_dev;
	touch_dev->xaxis = ABS_MT_POSITION_X;
	touch_dev->yaxis = ABS_MT_POSITION_Y;

	dev = &touch_dev->input_dev;
	dev->probe = huamobile_multi_touch_device_probe;
	dev->remove = NULL;
	dev->event_handler = huamobile_multi_touch_event_handler;

	return dev;
}
Ejemplo n.º 12
0
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;
}
Ejemplo n.º 13
0
static void bma2xx_input_chip_remove(struct cavan_input_chip *chip)
{
	struct cavan_sensor_device *sensor = cavan_input_chip_get_dev_data(chip);

	pr_pos_info();

	cavan_input_device_unregister(chip, &sensor->dev);
	kfree(sensor);
}
Ejemplo n.º 14
0
static void bl86x8_input_chip_remove(struct hua_input_chip *chip)
{
	struct hua_bl86x8_device *dev = hua_input_chip_get_dev_data(chip);

	pr_pos_info();

	hua_input_device_unregister(chip, &dev->ts.dev);
	kfree(dev);
}
Ejemplo n.º 15
0
static void adxl34x_input_chip_remove(struct hua_input_chip *chip)
{
	struct hua_sensor_device *sensor = hua_input_chip_get_dev_data(chip);

	pr_pos_info();

	hua_input_device_unregister(chip, &sensor->dev);
	kfree(sensor);
}
Ejemplo n.º 16
0
static void ltr553_input_chip_remove(struct cavan_input_chip *chip)
{
	struct cavan_ltr553_device *ltr553 = cavan_input_chip_get_dev_data(chip);

	pr_pos_info();

	cavan_input_device_unregister(chip, &ltr553->light.dev);
	cavan_input_device_unregister(chip, &ltr553->proxi.dev);
	kfree(ltr553);
}
Ejemplo n.º 17
0
static int HC548_input_open(struct input_dev *dev)
{
    struct HC548_touchscreen_data *data = input_get_drvdata(dev);

    pr_pos_info();

    HC548_start(data);

    return 0;
}
Ejemplo n.º 18
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;
}
Ejemplo n.º 19
0
static int bl86x8_i2c_remove(struct i2c_client *client)
{
	struct hua_input_chip *chip = i2c_get_clientdata(client);

	pr_pos_info();

	hua_input_chip_unregister(chip);
	kfree(chip);

	return 0;
}
Ejemplo n.º 20
0
static void cy8c242_input_chip_remove(struct cavan_input_chip *chip)
{
    struct cavan_cy8c242_device *dev = cavan_input_chip_get_dev_data(chip);

    pr_pos_info();

    device_remove_file(&((struct i2c_client *) chip->bus_data)->dev, &dev_attr_firmware_id);
    cavan_input_device_unregister(chip, &dev->prox.dev);
    cavan_input_device_unregister(chip, &dev->ts.dev);
    kfree(dev);
}
Ejemplo n.º 21
0
static int bma2xx_i2c_remove(struct i2c_client *client)
{
	struct cavan_input_chip *chip = i2c_get_clientdata(client);

	pr_pos_info();

	cavan_input_chip_unregister(chip);
	kfree(chip);

	return 0;
}
Ejemplo n.º 22
0
static int lis3dh_input_chip_probe(struct cavan_input_chip *chip)
{
    int ret;
    struct cavan_sensor_device *sensor;
    struct cavan_input_device *dev;

    pr_pos_info();

    sensor = kzalloc(sizeof(*sensor), GFP_KERNEL);
    if (sensor == NULL) {
        pr_red_info("kzalloc");
        return -ENOMEM;
    }

    cavan_input_chip_set_dev_data(chip, sensor);

    sensor->power_consume = 145;

    dev = &sensor->dev;
    dev->name = "LIS3DH Three-Axis Digital Accelerometer";
    dev->type = CAVAN_INPUT_DEVICE_TYPE_ACCELEROMETER;
    dev->min_delay = 20;
    dev->poll_delay = 200;
    dev->set_delay = lis3dh_acceleration_set_delay;

    if (strcmp(chip->name, "LIS3DH") == 0) {
        dev->fuzz = 32;
        dev->flat = 32;
        sensor->max_range = 2;
        sensor->resolution = 2048;
        dev->event_handler = lis3dh_acceleration_event_handler;
    } else {
        dev->fuzz = 0;
        dev->flat = 0;
        sensor->max_range = 4;
        sensor->resolution = 256;
        dev->event_handler = lis3de_acceleration_event_handler;
    }

    ret = cavan_input_device_register(chip, dev);
    if (ret < 0) {
        pr_red_info("cavan_input_device_register");
        goto out_kfree_sensor;
    }

    return 0;

out_kfree_sensor:
    kfree(sensor);
    return ret;
}
Ejemplo n.º 23
0
bool huamobile_multi_touch_device_matcher(int fd, const char *name, void *data)
{
	int ret;
	uint8_t abs_bitmask[ABS_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;
	}

	return huamobile_multi_touch_device_match(abs_bitmask);
}
Ejemplo n.º 24
0
static int mxc6225_input_chip_probe(struct cavan_input_chip *chip)
{
	int ret;
	struct cavan_sensor_device *sensor;
	struct cavan_input_device *dev;

	pr_pos_info();

	sensor = kzalloc(sizeof(*sensor), GFP_KERNEL);
	if (sensor == NULL) {
		pr_red_info("kzalloc");
		return -ENOMEM;
	}

	cavan_input_chip_set_dev_data(chip, sensor);

	sensor->power_consume = 145;

	dev = &sensor->dev;
	dev->name = "MXC6225 Two-Axis Digital Accelerometer";
	dev->type = CAVAN_INPUT_DEVICE_TYPE_ACCELEROMETER;
	dev->min_delay = 20;
	dev->poll_delay = 200;

	dev->fuzz = 4;
	dev->flat = 4;
	sensor->axis_count = 2;
	sensor->max_range = 4;
	sensor->resolution = 256;

	if (chip->devid == CHIP_ID_MXC6225XC) {
		dev->event_handler = mxc6225xc_acceleration_event_handler;
	} else {
		dev->event_handler = mxc6225xu_acceleration_event_handler;
	}

	ret = cavan_input_device_register(chip, dev);
	if (ret < 0) {
		pr_red_info("cavan_input_device_register");
		goto out_kfree_sensor;
	}

	return 0;

out_kfree_sensor:
	kfree(sensor);
	return ret;
}
Ejemplo n.º 25
0
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;
}
Ejemplo n.º 26
0
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;
}
Ejemplo n.º 27
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;
}
Ejemplo n.º 28
0
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;
}
Ejemplo n.º 29
0
static int adxl34x_i2c_remove(struct i2c_client *client)
{
	struct hua_input_chip *chip = i2c_get_clientdata(client);

	pr_pos_info();

	hua_input_chip_unregister(chip);

	if (chip->irq > 0)
	{
		sprd_free_eic_irq(chip->irq);
	}

	kfree(chip);

	return 0;
}
Ejemplo n.º 30
0
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;
}