drivers/hid/intel-thc-hid/intel-quicki2c/quicki2c-protocol.c

/* SPDX-License-Identifier: GPL-2.0-only */
/* Copyright (c) 2024 Intel Corporation */

#include <linux/bitfield.h>
#include <linux/hid.h>
#include <linux/hid-over-i2c.h>
#include <linux/unaligned.h>

#include "intel-thc-dev.h"
#include "intel-thc-dma.h"

#include "quicki2c-dev.h"
#include "quicki2c-hid.h"
#include "quicki2c-protocol.h"

static ssize_t quicki2c_init_write_buf(struct quicki2c_device *qcdev, u32 cmd, size_t cmd_len,
				       bool append_data_reg, u8 *data, size_t data_len,
				       u8 *write_buf, size_t write_buf_len)
{
	size_t buf_len, offset = 0;

	buf_len = HIDI2C_REG_LEN + cmd_len;

	if (append_data_reg)
		buf_len += HIDI2C_REG_LEN;

	if (data && data_len)
		buf_len += data_len + HIDI2C_LENGTH_LEN;

	if (buf_len > write_buf_len)
		return -EINVAL;

	if (cmd_len) {
		memcpy(write_buf, &qcdev->dev_desc.cmd_reg, HIDI2C_REG_LEN);
		offset += HIDI2C_REG_LEN;
		memcpy(write_buf + offset, &cmd, cmd_len);
		offset += cmd_len;

		if (append_data_reg) {
			memcpy(write_buf + offset, &qcdev->dev_desc.data_reg, HIDI2C_REG_LEN);
			offset += HIDI2C_REG_LEN;
		}
	} else {
		memcpy(write_buf, &qcdev->dev_desc.output_reg, HIDI2C_REG_LEN);
		offset += HIDI2C_REG_LEN;
	}

	if (data && data_len) {
		put_unaligned_le16(data_len + HIDI2C_LENGTH_LEN, write_buf + offset);
		offset += HIDI2C_LENGTH_LEN;
		memcpy(write_buf + offset, data, data_len);
	}

	return buf_len;
}

static size_t quicki2c_encode_cmd(struct quicki2c_device *qcdev, u32 *cmd_buf,
				  u8 opcode, u8 report_type, u8 report_id)
{
	size_t cmd_len;

	*cmd_buf = FIELD_PREP(HIDI2C_CMD_OPCODE, opcode) |
		   FIELD_PREP(HIDI2C_CMD_REPORT_TYPE, report_type);

	if (report_id < HIDI2C_CMD_MAX_RI) {
		*cmd_buf |= FIELD_PREP(HIDI2C_CMD_REPORT_ID, report_id);
		cmd_len = HIDI2C_CMD_LEN;
	} else {
		*cmd_buf |= FIELD_PREP(HIDI2C_CMD_REPORT_ID, HIDI2C_CMD_MAX_RI) |
			    FIELD_PREP(HIDI2C_CMD_3RD_BYTE, report_id);
		cmd_len = HIDI2C_CMD_LEN_OPT;
	}

	return cmd_len;
}

static int write_cmd_to_txdma(struct quicki2c_device *qcdev, int opcode,
			      int report_type, int report_id, u8 *buf, size_t buf_len)
{
	size_t cmd_len;
	ssize_t len;
	u32 cmd;

	cmd_len = quicki2c_encode_cmd(qcdev, &cmd, opcode, report_type, report_id);

	len = quicki2c_init_write_buf(qcdev, cmd, cmd_len, buf ? true : false, buf,
				      buf_len, qcdev->report_buf, qcdev->report_len);
	if (len < 0)
		return len;

	return thc_dma_write(qcdev->thc_hw, qcdev->report_buf, len);
}

int quicki2c_set_power(struct quicki2c_device *qcdev, enum hidi2c_power_state power_state)
{
	return write_cmd_to_txdma(qcdev, HIDI2C_SET_POWER, HIDI2C_RESERVED, power_state, NULL, 0);
}

int quicki2c_get_device_descriptor(struct quicki2c_device *qcdev)
{
	u32 read_len = 0;
	int ret;

	ret = thc_tic_pio_write_and_read(qcdev->thc_hw, qcdev->hid_desc_addr,
					 HIDI2C_REG_LEN, NULL, HIDI2C_DEV_DESC_LEN,
					 &read_len, (u32 *)&qcdev->dev_desc);
	if (ret || HIDI2C_DEV_DESC_LEN != read_len) {
		dev_err_once(qcdev->dev, "Get device descriptor failed, ret %d, read len %u\n",
			     ret, read_len);
		return -EIO;
	}

	if (le16_to_cpu(qcdev->dev_desc.bcd_ver) != HIDI2C_HID_DESC_BCDVERSION)
		return -EOPNOTSUPP;

	return 0;
}

int quicki2c_get_report_descriptor(struct quicki2c_device *qcdev)
{
	u16 desc_reg = le16_to_cpu(qcdev->dev_desc.report_desc_reg);
	size_t read_len = le16_to_cpu(qcdev->dev_desc.report_desc_len);
	u32 prd_len = read_len;

	return thc_swdma_read(qcdev->thc_hw, (u8 *)&desc_reg, HIDI2C_REG_LEN,
			      &prd_len, qcdev->report_descriptor, &read_len);
}

int quicki2c_get_report(struct quicki2c_device *qcdev, u8 report_type,
			unsigned int reportnum, void *buf, size_t buf_len)
{
	struct hidi2c_report_packet *rpt;
	size_t cmd_len, read_len = 0;
	int rep_type, ret;
	ssize_t len;
	u32 cmd;

	if (report_type == HID_INPUT_REPORT) {
		rep_type = HIDI2C_INPUT;
	} else if (report_type == HID_FEATURE_REPORT) {
		rep_type = HIDI2C_FEATURE;
	} else {
		dev_err(qcdev->dev, "Unsupported report type for GET REPORT: %d\n", report_type);
		return -EINVAL;
	}

	cmd_len = quicki2c_encode_cmd(qcdev, &cmd, HIDI2C_GET_REPORT, rep_type, reportnum);

	len = quicki2c_init_write_buf(qcdev, cmd, cmd_len, true, NULL, 0,
				      qcdev->report_buf, qcdev->report_len);
	if (len < 0)
		return len;

	rpt = (struct hidi2c_report_packet *)qcdev->input_buf;

	ret = thc_swdma_read(qcdev->thc_hw, qcdev->report_buf, len, NULL, rpt, &read_len);
	if (ret) {
		dev_err_once(qcdev->dev, "Get report failed, ret %d, read len (%zu vs %zu)\n",
			     ret, read_len, buf_len);
		return ret;
	}

	if (HIDI2C_DATA_LEN(le16_to_cpu(rpt->len)) != buf_len || rpt->data[0] != reportnum) {
		dev_err_once(qcdev->dev, "Invalid packet, len (%d vs %zu) report id (%d vs %d)\n",
			     le16_to_cpu(rpt->len), buf_len, rpt->data[0], reportnum);
		return -EINVAL;
	}

	memcpy(buf, rpt->data, buf_len);

	return buf_len;
}

int quicki2c_set_report(struct quicki2c_device *qcdev, u8 report_type,
			unsigned int reportnum, void *buf, size_t buf_len)
{
	int rep_type;
	int ret;

	if (report_type == HID_OUTPUT_REPORT) {
		rep_type = HIDI2C_OUTPUT;
	} else if (report_type == HID_FEATURE_REPORT) {
		rep_type = HIDI2C_FEATURE;
	} else {
		dev_err(qcdev->dev, "Unsupported report type for SET REPORT: %d\n", report_type);
		return -EINVAL;
	}

	ret = write_cmd_to_txdma(qcdev, HIDI2C_SET_REPORT, rep_type, reportnum, buf, buf_len);
	if (ret) {
		dev_err_once(qcdev->dev, "Set Report failed, ret %d\n", ret);
		return ret;
	}

	return buf_len;
}

int quicki2c_output_report(struct quicki2c_device *qcdev, void *buf, size_t buf_len)
{
	ssize_t len;
	int ret;

	len = quicki2c_init_write_buf(qcdev, 0, 0, false, buf, buf_len,
				      qcdev->report_buf, qcdev->report_len);
	if (len < 0)
		return -EINVAL;

	ret = thc_dma_write(qcdev->thc_hw, qcdev->report_buf, len);
	if (ret) {
		dev_err(qcdev->dev, "Output Report failed, ret %d\n", ret);
		return ret;
	}

	return buf_len;
}

#define HIDI2C_RESET_TIMEOUT		5

int quicki2c_reset(struct quicki2c_device *qcdev)
{
	u16 input_reg = le16_to_cpu(qcdev->dev_desc.input_reg);
	size_t read_len = HIDI2C_LENGTH_LEN;
	u32 prd_len = read_len;
	int ret;

	qcdev->reset_ack = false;
	qcdev->state = QUICKI2C_RESETING;

	ret = write_cmd_to_txdma(qcdev, HIDI2C_RESET, HIDI2C_RESERVED, 0, NULL, 0);
	if (ret) {
		dev_err_once(qcdev->dev, "Send reset command failed, ret %d\n", ret);
		return ret;
	}

	ret = wait_event_interruptible_timeout(qcdev->reset_ack_wq, qcdev->reset_ack,
					       HIDI2C_RESET_TIMEOUT * HZ);
	if (qcdev->reset_ack)
		return 0;

	/*
	 * Manually read reset response if it wasn't received, in case reset interrupt
	 * was missed by touch device or THC hardware.
	 */
	ret = thc_tic_pio_read(qcdev->thc_hw, input_reg, read_len, &prd_len,
			       (u32 *)qcdev->input_buf);
	if (ret) {
		dev_err_once(qcdev->dev, "Read Reset Response failed, ret %d\n", ret);
		return ret;
	}

	/*
	 * Check response packet length, it's first 16 bits of packet.
	 * If response packet length is zero, it's reset response, otherwise not.
	 */
	if (get_unaligned_le16(qcdev->input_buf)) {
		dev_err_once(qcdev->dev,
			     "Wait reset response timed out ret:%d timeout:%ds\n",
			     ret, HIDI2C_RESET_TIMEOUT);
		return -ETIMEDOUT;
	}

	qcdev->reset_ack = true;

	return 0;
}