Lines Matching defs:ts

63 static int goodix_check_cfg_8(struct goodix_ts_data *ts,
65 static int goodix_check_cfg_16(struct goodix_ts_data *ts,
67 static void goodix_calc_cfg_checksum_8(struct goodix_ts_data *ts);
68 static void goodix_calc_cfg_checksum_16(struct goodix_ts_data *ts);
253 static int goodix_ts_read_input_report(struct goodix_ts_data *ts, u8 *data)
261 	 * ts->contact_size * max(1, touch_num) bytes of coordinates
264 	const int header_contact_keycode_size = 1 + ts->contact_size + 1;
273 		error = goodix_i2c_read(ts->client, addr, data,
280 			if (touch_num > ts->max_touch_num)
286 				error = goodix_i2c_read(ts->client,
288 						ts->contact_size *
297 		if (data[0] == 0 && ts->firmware_name) {
298 			if (goodix_handle_fw_request(ts))
312 static int goodix_create_pen_input(struct goodix_ts_data *ts)
314 	struct device *dev = &ts->client->dev;
321 	input_copy_abs(input, ABS_X, ts->input_dev, ABS_MT_POSITION_X);
322 	input_copy_abs(input, ABS_Y, ts->input_dev, ABS_MT_POSITION_Y);
342 	if (kstrtou16(ts->id, 10, &input->id.product))
344 	input->id.version = ts->version;
346 	ts->input_pen = input;
350 static void goodix_ts_report_pen_down(struct goodix_ts_data *ts, u8 *data)
355 	if (!ts->pen_input_registered) {
356 		error = input_register_device(ts->input_pen);
357 		ts->pen_input_registered = (error == 0) ? 1 : error;
360 	if (ts->pen_input_registered < 0)
363 	if (ts->contact_size == 9) {
373 	touchscreen_report_pos(ts->input_pen, &ts->prop, input_x, input_y, false);
374 	input_report_abs(ts->input_pen, ABS_PRESSURE, input_w);
376 	input_report_key(ts->input_pen, BTN_TOUCH, 1);
377 	input_report_key(ts->input_pen, BTN_TOOL_PEN, 1);
380 		key_value = data[1 + ts->contact_size];
381 		input_report_key(ts->input_pen, BTN_STYLUS, key_value & 0x10);
382 		input_report_key(ts->input_pen, BTN_STYLUS2, key_value & 0x20);
384 		input_report_key(ts->input_pen, BTN_STYLUS, 0);
385 		input_report_key(ts->input_pen, BTN_STYLUS2, 0);
388 	input_sync(ts->input_pen);
391 static void goodix_ts_report_pen_up(struct goodix_ts_data *ts)
393 	if (!ts->input_pen)
396 	input_report_key(ts->input_pen, BTN_TOUCH, 0);
397 	input_report_key(ts->input_pen, BTN_TOOL_PEN, 0);
398 	input_report_key(ts->input_pen, BTN_STYLUS, 0);
399 	input_report_key(ts->input_pen, BTN_STYLUS2, 0);
401 	input_sync(ts->input_pen);
404 static void goodix_ts_report_touch_8b(struct goodix_ts_data *ts, u8 *coor_data)
411 	input_mt_slot(ts->input_dev, id);
412 	input_mt_report_slot_state(ts->input_dev, MT_TOOL_FINGER, true);
413 	touchscreen_report_pos(ts->input_dev, &ts->prop,
415 	input_report_abs(ts->input_dev, ABS_MT_TOUCH_MAJOR, input_w);
416 	input_report_abs(ts->input_dev, ABS_MT_WIDTH_MAJOR, input_w);
419 static void goodix_ts_report_touch_9b(struct goodix_ts_data *ts, u8 *coor_data)
426 	input_mt_slot(ts->input_dev, id);
427 	input_mt_report_slot_state(ts->input_dev, MT_TOOL_FINGER, true);
428 	touchscreen_report_pos(ts->input_dev, &ts->prop,
430 	input_report_abs(ts->input_dev, ABS_MT_TOUCH_MAJOR, input_w);
431 	input_report_abs(ts->input_dev, ABS_MT_WIDTH_MAJOR, input_w);
434 static void goodix_ts_release_keys(struct goodix_ts_data *ts)
439 		input_report_key(ts->input_dev, ts->keymap[i], 0);
442 static void goodix_ts_report_key(struct goodix_ts_data *ts, u8 *data)
450 		key_value = data[1 + ts->contact_size * touch_num];
453 				input_report_key(ts->input_dev,
454 						 ts->keymap[i], 1);
456 		goodix_ts_release_keys(ts);
463  * @ts: our goodix_ts_data pointer
468 static void goodix_process_events(struct goodix_ts_data *ts)
474 	touch_num = goodix_ts_read_input_report(ts, point_data);
480 		goodix_ts_report_pen_down(ts, point_data);
481 		goodix_ts_release_keys(ts);
484 		goodix_ts_report_pen_up(ts);
487 	goodix_ts_report_key(ts, point_data);
490 		if (ts->contact_size == 9)
491 			goodix_ts_report_touch_9b(ts,
492 				&point_data[1 + ts->contact_size * i]);
494 			goodix_ts_report_touch_8b(ts,
495 				&point_data[1 + ts->contact_size * i]);
498 	input_mt_sync_frame(ts->input_dev);
499 	input_sync(ts->input_dev);
504 	struct goodix_ts_data *ts = input_get_drvdata(input);
506 	goodix_process_events(ts);
507 	goodix_i2c_write_u8(ts->client, GOODIX_READ_COOR_ADDR, 0);
518 	struct goodix_ts_data *ts = dev_id;
520 	goodix_process_events(ts);
521 	goodix_i2c_write_u8(ts->client, GOODIX_READ_COOR_ADDR, 0);
526 static void goodix_enable_irq(struct goodix_ts_data *ts)
528 	if (ts->client->irq)
529 		enable_irq(ts->client->irq);
532 static void goodix_disable_irq(struct goodix_ts_data *ts)
534 	if (ts->client->irq)
535 		disable_irq(ts->client->irq);
538 static void goodix_free_irq(struct goodix_ts_data *ts)
540 	if (ts->client->irq)
541 		devm_free_irq(&ts->client->dev, ts->client->irq, ts);
544 static int goodix_request_irq(struct goodix_ts_data *ts)
546 	if (!ts->client->irq)
549 	return devm_request_threaded_irq(&ts->client->dev, ts->client->irq,
551 					 ts->irq_flags, ts->client->name, ts);
554 static int goodix_check_cfg_8(struct goodix_ts_data *ts, const u8 *cfg, int len)
563 		dev_err(&ts->client->dev,
569 		dev_err(&ts->client->dev,
577 static void goodix_calc_cfg_checksum_8(struct goodix_ts_data *ts)
579 	int i, raw_cfg_len = ts->chip->config_len - 2;
583 		check_sum += ts->config[i];
586 	ts->config[raw_cfg_len] = check_sum;
587 	ts->config[raw_cfg_len + 1] = 1; /* Set "config_fresh" bit */
590 static int goodix_check_cfg_16(struct goodix_ts_data *ts, const u8 *cfg,
600 		dev_err(&ts->client->dev,
606 		dev_err(&ts->client->dev,
614 static void goodix_calc_cfg_checksum_16(struct goodix_ts_data *ts)
616 	int i, raw_cfg_len = ts->chip->config_len - 3;
620 		check_sum += get_unaligned_be16(&ts->config[i]);
623 	put_unaligned_be16(check_sum, &ts->config[raw_cfg_len]);
624 	ts->config[raw_cfg_len + 2] = 1; /* Set "config_fresh" bit */
630  * @ts: goodix_ts_data pointer
634 static int goodix_check_cfg(struct goodix_ts_data *ts, const u8 *cfg, int len)
638 		dev_err(&ts->client->dev,
643 	return ts->chip->check_config(ts, cfg, len);
649  * @ts: goodix_ts_data pointer
653 int goodix_send_cfg(struct goodix_ts_data *ts, const u8 *cfg, int len)
657 	error = goodix_check_cfg(ts, cfg, len);
661 	error = goodix_i2c_write(ts->client, ts->chip->config_addr, cfg, len);
665 	dev_dbg(&ts->client->dev, "Config sent successfully.");
674 static int goodix_pin_acpi_direction_input(struct goodix_ts_data *ts)
676 	acpi_handle handle = ACPI_HANDLE(&ts->client->dev);
683 static int goodix_pin_acpi_output_method(struct goodix_ts_data *ts, int value)
685 	acpi_handle handle = ACPI_HANDLE(&ts->client->dev);
692 static int goodix_pin_acpi_direction_input(struct goodix_ts_data *ts)
694 	dev_err(&ts->client->dev,
699 static int goodix_pin_acpi_output_method(struct goodix_ts_data *ts, int value)
701 	dev_err(&ts->client->dev,
707 static int goodix_irq_direction_output(struct goodix_ts_data *ts, int value)
709 	switch (ts->irq_pin_access_method) {
711 		dev_err(&ts->client->dev,
716 		return gpiod_direction_output(ts->gpiod_int, value);
722 		return gpiod_direction_output_raw(ts->gpiod_int, value);
724 		return goodix_pin_acpi_output_method(ts, value);
730 static int goodix_irq_direction_input(struct goodix_ts_data *ts)
732 	switch (ts->irq_pin_access_method) {
734 		dev_err(&ts->client->dev,
739 		return gpiod_direction_input(ts->gpiod_int);
741 		return gpiod_direction_input(ts->gpiod_int);
743 		return goodix_pin_acpi_direction_input(ts);
749 int goodix_int_sync(struct goodix_ts_data *ts)
753 	error = goodix_irq_direction_output(ts, 0);
759 	error = goodix_irq_direction_input(ts);
766 	dev_err(&ts->client->dev, "Controller irq sync failed.\n");
773  * @ts: goodix_ts_data pointer
775 int goodix_reset_no_int_sync(struct goodix_ts_data *ts)
780 	error = gpiod_direction_output(ts->gpiod_rst, 0);
787 	error = goodix_irq_direction_output(ts, ts->client->addr == 0x14);
793 	error = gpiod_direction_output(ts->gpiod_rst, 1);
804 	if (ts->irq_pin_access_method == IRQ_PIN_ACCESS_GPIO) {
805 		error = gpiod_direction_input(ts->gpiod_rst);
813 	dev_err(&ts->client->dev, "Controller reset failed.\n");
820  * @ts: goodix_ts_data pointer
822 static int goodix_reset(struct goodix_ts_data *ts)
826 	error = goodix_reset_no_int_sync(ts);
830 	return goodix_int_sync(ts);
856 	struct goodix_ts_data *ts = data;
857 	struct device *dev = &ts->client->dev;
861 		if (ts->gpio_int_idx == -1) {
862 			ts->gpio_int_idx = ts->gpio_count;
865 			ts->gpio_int_idx = -2;
867 		ts->gpio_count++;
869 		ts->gpio_count++;
881 static int goodix_add_acpi_gpio_mappings(struct goodix_ts_data *ts)
884 	struct device *dev = &ts->client->dev;
888 	ts->gpio_count = 0;
889 	ts->gpio_int_idx = -1;
891 				     goodix_resource, ts);
905 	if (soc_intel_is_cht() && ts->gpio_count == 2 && ts->gpio_int_idx != -1) {
907 		if (irq > 0 && irq != ts->client->irq) {
908 			dev_warn(dev, "Overriding IRQ %d -> %d\n", ts->client->irq, irq);
909 			ts->client->irq = irq;
914 	if ((ts->gpio_count == 2 || ts->gpio_count == 3) && ts->gpio_int_idx == 0) {
915 		ts->irq_pin_access_method = IRQ_PIN_ACCESS_ACPI_GPIO;
917 	} else if (ts->gpio_count == 2 && ts->gpio_int_idx == 1) {
918 		ts->irq_pin_access_method = IRQ_PIN_ACCESS_ACPI_GPIO;
920 	} else if (ts->gpio_count == 1 && ts->gpio_int_idx == -1 &&
924 		ts->irq_pin_access_method = IRQ_PIN_ACCESS_ACPI_METHOD;
926 	} else if (soc_intel_is_byt() && ts->gpio_count == 2 && ts->gpio_int_idx == -1) {
928 		ts->irq_pin_access_method = IRQ_PIN_ACCESS_ACPI_GPIO;
930 	} else if (ts->gpio_count == 1 && ts->gpio_int_idx == 0) {
947 		ts->irq_pin_access_method = IRQ_PIN_ACCESS_NONE;
951 			 ts->gpio_count, ts->gpio_int_idx);
966 	ts->gpiod_rst_flags = GPIOD_ASIS;
971 static int goodix_add_acpi_gpio_mappings(struct goodix_ts_data *ts)
980  * @ts: goodix_ts_data pointer
982 static int goodix_get_gpio_config(struct goodix_ts_data *ts)
988 	if (!ts->client)
990 	dev = &ts->client->dev;
996 	ts->gpiod_rst_flags = GPIOD_IN;
998 	ts->avdd28 = devm_regulator_get(dev, "AVDD28");
999 	if (IS_ERR(ts->avdd28))
1000 		return dev_err_probe(dev, PTR_ERR(ts->avdd28), "Failed to get AVDD28 regulator\n");
1002 	ts->vddio = devm_regulator_get(dev, "VDDIO");
1003 	if (IS_ERR(ts->vddio))
1004 		return dev_err_probe(dev, PTR_ERR(ts->vddio), "Failed to get VDDIO regulator\n");
1015 		if (goodix_add_acpi_gpio_mappings(ts) == 0)
1019 	ts->gpiod_int = gpiod;
1022 	gpiod = devm_gpiod_get_optional(dev, GOODIX_GPIO_RST_NAME, ts->gpiod_rst_flags);
1027 	ts->gpiod_rst = gpiod;
1029 	switch (ts->irq_pin_access_method) {
1039 		if (!ts->gpiod_int || !ts->gpiod_rst)
1040 			ts->irq_pin_access_method = IRQ_PIN_ACCESS_NONE;
1043 		if (!ts->gpiod_rst)
1044 			ts->irq_pin_access_method = IRQ_PIN_ACCESS_NONE;
1047 		if (ts->gpiod_int && ts->gpiod_rst) {
1048 			ts->reset_controller_at_probe = true;
1049 			ts->load_cfg_from_disk = true;
1050 			ts->irq_pin_access_method = IRQ_PIN_ACCESS_GPIO;
1060  * @ts: our goodix_ts_data pointer
1064 static void goodix_read_config(struct goodix_ts_data *ts)
1071 	 * (controllers without flash) ts->config already has the config
1074 	if (!ts->firmware_name) {
1075 		error = goodix_i2c_read(ts->client, ts->chip->config_addr,
1076 					ts->config, ts->chip->config_len);
1078 			ts->int_trigger_type = GOODIX_INT_TRIGGER;
1079 			ts->max_touch_num = GOODIX_MAX_CONTACTS;
1084 	ts->int_trigger_type = ts->config[TRIGGER_LOC] & 0x03;
1085 	ts->max_touch_num = ts->config[MAX_CONTACTS_LOC] & 0x0f;
1087 	x_max = get_unaligned_le16(&ts->config[RESOLUTION_LOC]);
1088 	y_max = get_unaligned_le16(&ts->config[RESOLUTION_LOC + 2]);
1090 		input_abs_set_max(ts->input_dev, ABS_MT_POSITION_X, x_max - 1);
1091 		input_abs_set_max(ts->input_dev, ABS_MT_POSITION_Y, y_max - 1);
1094 	ts->chip->calc_config_checksum(ts);
1100  * @ts: our goodix_ts_data pointer
1102 static int goodix_read_version(struct goodix_ts_data *ts)
1108 	error = goodix_i2c_read(ts->client, GOODIX_REG_ID, buf, sizeof(buf));
1114 	strscpy(ts->id, id_str, GOODIX_ID_MAX_LEN + 1);
1116 	ts->version = get_unaligned_le16(&buf[4]);
1118 	dev_info(&ts->client->dev, "ID %s, version: %04x\n", ts->id,
1119 		 ts->version);
1149  * @ts: our goodix_ts_data pointer
1156 static int goodix_configure_dev(struct goodix_ts_data *ts)
1161 	ts->int_trigger_type = GOODIX_INT_TRIGGER;
1162 	ts->max_touch_num = GOODIX_MAX_CONTACTS;
1164 	ts->input_dev = devm_input_allocate_device(&ts->client->dev);
1165 	if (!ts->input_dev) {
1166 		dev_err(&ts->client->dev, "Failed to allocate input device.");
1170 	ts->input_dev->name = "Goodix Capacitive TouchScreen";
1171 	ts->input_dev->phys = "input/ts";
1172 	ts->input_dev->id.bustype = BUS_I2C;
1173 	ts->input_dev->id.vendor = 0x0416;
1174 	if (kstrtou16(ts->id, 10, &ts->input_dev->id.product))
1175 		ts->input_dev->id.product = 0x1001;
1176 	ts->input_dev->id.version = ts->version;
1178 	ts->input_dev->keycode = ts->keymap;
1179 	ts->input_dev->keycodesize = sizeof(ts->keymap[0]);
1180 	ts->input_dev->keycodemax = GOODIX_MAX_KEYS;
1185 			ts->keymap[i] = KEY_LEFTMETA;
1187 			ts->keymap[i] = KEY_F1 + (i - 1);
1189 		input_set_capability(ts->input_dev, EV_KEY, ts->keymap[i]);
1192 	input_set_capability(ts->input_dev, EV_ABS, ABS_MT_POSITION_X);
1193 	input_set_capability(ts->input_dev, EV_ABS, ABS_MT_POSITION_Y);
1194 	input_set_abs_params(ts->input_dev, ABS_MT_WIDTH_MAJOR, 0, 255, 0, 0);
1195 	input_set_abs_params(ts->input_dev, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
1199 	goodix_read_config(ts);
1202 	touchscreen_parse_properties(ts->input_dev, true, &ts->prop);
1204 	if (!ts->prop.max_x || !ts->prop.max_y || !ts->max_touch_num) {
1205 		if (!ts->reset_controller_at_probe &&
1206 		    ts->irq_pin_access_method != IRQ_PIN_ACCESS_NONE) {
1207 			dev_info(&ts->client->dev, "Config not set, resetting controller\n");
1209 			ts->reset_controller_at_probe = true;
1210 			error = goodix_reset(ts);
1215 		dev_err(&ts->client->dev,
1217 			ts->prop.max_x, ts->prop.max_y, ts->max_touch_num);
1218 		ts->prop.max_x = GOODIX_MAX_WIDTH - 1;
1219 		ts->prop.max_y = GOODIX_MAX_HEIGHT - 1;
1220 		ts->max_touch_num = GOODIX_MAX_CONTACTS;
1221 		input_abs_set_max(ts->input_dev,
1222 				  ABS_MT_POSITION_X, ts->prop.max_x);
1223 		input_abs_set_max(ts->input_dev,
1224 				  ABS_MT_POSITION_Y, ts->prop.max_y);
1228 		ts->contact_size = 9;
1230 		dev_dbg(&ts->client->dev,
1235 		ts->prop.invert_x = true;
1236 		dev_dbg(&ts->client->dev,
1240 	error = input_mt_init_slots(ts->input_dev, ts->max_touch_num,
1243 		dev_err(&ts->client->dev,
1248 	input_set_drvdata(ts->input_dev, ts);
1250 	if (!ts->client->irq) {
1251 		error = input_setup_polling(ts->input_dev, goodix_ts_work_i2c_poll);
1253 			dev_err(&ts->client->dev,
1257 		input_set_poll_interval(ts->input_dev, GOODIX_POLL_INTERVAL_MS);
1260 	error = input_register_device(ts->input_dev);
1262 		dev_err(&ts->client->dev,
1274 	error = goodix_create_pen_input(ts);
1278 	ts->irq_flags = goodix_irq_flags[ts->int_trigger_type] | IRQF_ONESHOT;
1279 	error = goodix_request_irq(ts);
1281 		dev_err(&ts->client->dev, "request IRQ failed: %d\n", error);
1299 	struct goodix_ts_data *ts = ctx;
1302 	if (ts->firmware_name) {
1306 		error = goodix_check_cfg(ts, cfg->data, cfg->size);
1310 		memcpy(ts->config, cfg->data, cfg->size);
1313 		error = goodix_send_cfg(ts, cfg->data, cfg->size);
1318 	goodix_configure_dev(ts);
1322 	complete_all(&ts->firmware_loading_complete);
1327 	struct goodix_ts_data *ts = arg;
1329 	regulator_disable(ts->vddio);
1330 	regulator_disable(ts->avdd28);
1335 	struct goodix_ts_data *ts;
1346 	ts = devm_kzalloc(&client->dev, sizeof(*ts), GFP_KERNEL);
1347 	if (!ts)
1350 	ts->client = client;
1351 	i2c_set_clientdata(client, ts);
1352 	init_completion(&ts->firmware_loading_complete);
1353 	ts->contact_size = GOODIX_CONTACT_SIZE;
1355 	error = goodix_get_gpio_config(ts);
1360 	error = regulator_enable(ts->avdd28);
1368 	error = regulator_enable(ts->vddio);
1373 		regulator_disable(ts->avdd28);
1378 					 goodix_disable_regulators, ts);
1383 	if (ts->reset_controller_at_probe) {
1385 		error = goodix_reset(ts);
1392 		if (!ts->reset_controller_at_probe &&
1393 		    ts->irq_pin_access_method != IRQ_PIN_ACCESS_NONE) {
1395 			ts->reset_controller_at_probe = true;
1402 	error = goodix_firmware_check(ts);
1406 	error = goodix_read_version(ts);
1410 	ts->chip = goodix_get_chip_data(ts->id);
1412 	if (ts->load_cfg_from_disk) {
1418 			snprintf(ts->cfg_name, sizeof(ts->cfg_name),
1421 			snprintf(ts->cfg_name, sizeof(ts->cfg_name),
1422 				 "goodix_%s_cfg.bin", ts->id);
1424 		error = request_firmware_nowait(THIS_MODULE, true, ts->cfg_name,
1425 						&client->dev, GFP_KERNEL, ts,
1436 		error = goodix_configure_dev(ts);
1446 	struct goodix_ts_data *ts = i2c_get_clientdata(client);
1448 	if (ts->load_cfg_from_disk)
1449 		wait_for_completion(&ts->firmware_loading_complete);
1455 	struct goodix_ts_data *ts = i2c_get_clientdata(client);
1458 	if (ts->load_cfg_from_disk)
1459 		wait_for_completion(&ts->firmware_loading_complete);
1462 	if (ts->irq_pin_access_method == IRQ_PIN_ACCESS_NONE) {
1463 		goodix_disable_irq(ts);
1468 	goodix_free_irq(ts);
1471 	goodix_save_bak_ref(ts);
1474 	error = goodix_irq_direction_output(ts, 0);
1476 		goodix_request_irq(ts);
1482 	error = goodix_i2c_write_u8(ts->client, GOODIX_REG_COMMAND,
1485 		goodix_irq_direction_input(ts);
1486 		goodix_request_irq(ts);
1502 	struct goodix_ts_data *ts = i2c_get_clientdata(client);
1506 	if (ts->irq_pin_access_method == IRQ_PIN_ACCESS_NONE) {
1507 		goodix_enable_irq(ts);
1515 	error = goodix_irq_direction_output(ts, 1);
1521 	error = goodix_int_sync(ts);
1525 	error = goodix_i2c_read(ts->client, ts->chip->config_addr,
1527 	if (!error && config_ver != ts->config[0])
1529 			 config_ver, ts->config[0]);
1531 	if (error != 0 || config_ver != ts->config[0]) {
1532 		error = goodix_reset(ts);
1536 		error = goodix_send_cfg(ts, ts->config, ts->chip->config_len);
1541 	error = goodix_request_irq(ts);