Commit c5567175 authored by Jiri Kosina's avatar Jiri Kosina
Browse files

Merge branch 'for-5.20/amd-sfh' into for-linus 

- support for AMD SOCs using SFH1.1 memory access (Basavaraj Natikar)
parents 1117d182 5d4d0f15

drivers/hid/amd-sfh-hid/Makefile

+3 −0
Original line number Diff line number Diff line
@@ -9,5 +9,8 @@ amd_sfh-objs := amd_sfh_hid.o 
amd_sfh-objs += amd_sfh_client.o

amd_sfh-objs += amd_sfh_pcie.o

amd_sfh-objs += hid_descriptor/amd_sfh_hid_desc.o

amd_sfh-objs += sfh1_1/amd_sfh_init.o

amd_sfh-objs += sfh1_1/amd_sfh_interface.o

amd_sfh-objs += sfh1_1/amd_sfh_desc.o



ccflags-y += -I $(srctree)/$(src)/

drivers/hid/amd-sfh-hid/amd_sfh_client.c

+85 −32
Original line number Diff line number Diff line
@@ -18,18 +18,6 @@ 
#include "amd_sfh_pcie.h"

#include "amd_sfh_hid.h"





struct request_list {

	struct hid_device *hid;

	struct list_head list;

	u8 report_id;

	u8 sensor_idx;

	u8 report_type;

	u8 current_index;

};



static struct request_list req_list;



void amd_sfh_set_report(struct hid_device *hid, int report_id,

			int report_type)

{
@@ -50,6 +38,7 @@ int amd_sfh_get_report(struct hid_device *hid, int report_id, int report_type) 
{

	struct amdtp_hid_data *hid_data = hid->driver_data;

	struct amdtp_cl_data *cli_data = hid_data->cli_data;

	struct request_list *req_list = &cli_data->req_list;

	int i;



	for (i = 0; i < cli_data->num_hid_devices; i++) {
@@ -66,7 +55,7 @@ int amd_sfh_get_report(struct hid_device *hid, int report_id, int report_type) 
			new->report_id = report_id;

			cli_data->report_id[i] = report_id;

			cli_data->request_done[i] = false;

			list_add(&new->list, &req_list.list);

			list_add(&new->list, &req_list->list);

			break;

		}

	}
@@ -74,16 +63,19 @@ int amd_sfh_get_report(struct hid_device *hid, int report_id, int report_type) 
	return 0;

}



static void amd_sfh_work(struct work_struct *work)

void amd_sfh_work(struct work_struct *work)

{

	struct amdtp_cl_data *cli_data = container_of(work, struct amdtp_cl_data, work.work);

	struct request_list *req_list = &cli_data->req_list;

	struct amd_input_data *in_data = cli_data->in_data;

	struct request_list *req_node;

	u8 current_index, sensor_index;

	struct amd_mp2_ops *mp2_ops;

	struct amd_mp2_dev *mp2;

	u8 report_id, node_type;

	u8 report_size = 0;



	req_node = list_last_entry(&req_list.list, struct request_list, list);

	req_node = list_last_entry(&req_list->list, struct request_list, list);

	list_del(&req_node->list);

	current_index = req_node->current_index;

	sensor_index = req_node->sensor_idx;
@@ -91,8 +83,10 @@ static void amd_sfh_work(struct work_struct *work) 
	node_type = req_node->report_type;

	kfree(req_node);



	mp2 = container_of(in_data, struct amd_mp2_dev, in_data);

	mp2_ops = mp2->mp2_ops;

	if (node_type == HID_FEATURE_REPORT) {

		report_size = get_feature_report(sensor_index, report_id,

		report_size = mp2_ops->get_feat_rep(sensor_index, report_id,

						    cli_data->feature_report[current_index]);

		if (report_size)

			hid_input_report(cli_data->hid_sensor_hubs[current_index],
@@ -102,7 +96,7 @@ static void amd_sfh_work(struct work_struct *work) 
			pr_err("AMDSFH: Invalid report size\n");



	} else if (node_type == HID_INPUT_REPORT) {

		report_size = get_input_report(current_index, sensor_index, report_id, in_data);

		report_size = mp2_ops->get_in_rep(current_index, sensor_index, report_id, in_data);

		if (report_size)

			hid_input_report(cli_data->hid_sensor_hubs[current_index],

					 cli_data->report_type[current_index],
@@ -115,17 +109,19 @@ static void amd_sfh_work(struct work_struct *work) 
	amdtp_hid_wakeup(cli_data->hid_sensor_hubs[current_index]);

}



static void amd_sfh_work_buffer(struct work_struct *work)

void amd_sfh_work_buffer(struct work_struct *work)

{

	struct amdtp_cl_data *cli_data = container_of(work, struct amdtp_cl_data, work_buffer.work);

	struct amd_input_data *in_data = cli_data->in_data;

	struct amd_mp2_dev *mp2;

	u8 report_size;

	int i;



	for (i = 0; i < cli_data->num_hid_devices; i++) {

		if (cli_data->sensor_sts[i] == SENSOR_ENABLED) {

			report_size = get_input_report

				(i, cli_data->sensor_idx[i], cli_data->report_id[i], in_data);

			mp2 = container_of(in_data, struct amd_mp2_dev, in_data);

			report_size = mp2->mp2_ops->get_in_rep(i, cli_data->sensor_idx[i],

							       cli_data->report_id[i], in_data);

			hid_input_report(cli_data->hid_sensor_hubs[i], HID_INPUT_REPORT,

					 in_data->input_report[i], report_size, 0);

		}
@@ -133,7 +129,7 @@ static void amd_sfh_work_buffer(struct work_struct *work) 
	schedule_delayed_work(&cli_data->work_buffer, msecs_to_jiffies(AMD_SFH_IDLE_LOOP));

}



u32 amd_sfh_wait_for_response(struct amd_mp2_dev *mp2, u8 sid, u32 sensor_sts)

static u32 amd_sfh_wait_for_response(struct amd_mp2_dev *mp2, u8 sid, u32 sensor_sts)

{

	if (mp2->mp2_ops->response)

		sensor_sts = mp2->mp2_ops->response(mp2, sid, sensor_sts);
@@ -141,7 +137,7 @@ u32 amd_sfh_wait_for_response(struct amd_mp2_dev *mp2, u8 sid, u32 sensor_sts) 
	return sensor_sts;

}



const char *get_sensor_name(int idx)

static const char *get_sensor_name(int idx)

{

	switch (idx) {

	case accel_idx:
@@ -159,24 +155,82 @@ const char *get_sensor_name(int idx) 
	}

}



static void amd_sfh_resume(struct amd_mp2_dev *mp2)

{

	struct amdtp_cl_data *cl_data = mp2->cl_data;

	struct amd_mp2_sensor_info info;

	int i, status;



	for (i = 0; i < cl_data->num_hid_devices; i++) {

		if (cl_data->sensor_sts[i] == SENSOR_DISABLED) {

			info.period = AMD_SFH_IDLE_LOOP;

			info.sensor_idx = cl_data->sensor_idx[i];

			info.dma_address = cl_data->sensor_dma_addr[i];

			mp2->mp2_ops->start(mp2, info);

			status = amd_sfh_wait_for_response

					(mp2, cl_data->sensor_idx[i], SENSOR_ENABLED);

			if (status == SENSOR_ENABLED)

				cl_data->sensor_sts[i] = SENSOR_ENABLED;

			dev_dbg(&mp2->pdev->dev, "resume sid 0x%x (%s) status 0x%x\n",

				cl_data->sensor_idx[i], get_sensor_name(cl_data->sensor_idx[i]),

				cl_data->sensor_sts[i]);

		}

	}



	schedule_delayed_work(&cl_data->work_buffer, msecs_to_jiffies(AMD_SFH_IDLE_LOOP));

	amd_sfh_clear_intr(mp2);

}



static void amd_sfh_suspend(struct amd_mp2_dev *mp2)

{

	struct amdtp_cl_data *cl_data = mp2->cl_data;

	int i, status;



	for (i = 0; i < cl_data->num_hid_devices; i++) {

		if (cl_data->sensor_idx[i] != HPD_IDX &&

		    cl_data->sensor_sts[i] == SENSOR_ENABLED) {

			mp2->mp2_ops->stop(mp2, cl_data->sensor_idx[i]);

			status = amd_sfh_wait_for_response

					(mp2, cl_data->sensor_idx[i], SENSOR_DISABLED);

			if (status != SENSOR_ENABLED)

				cl_data->sensor_sts[i] = SENSOR_DISABLED;

			dev_dbg(&mp2->pdev->dev, "suspend sid 0x%x (%s) status 0x%x\n",

				cl_data->sensor_idx[i], get_sensor_name(cl_data->sensor_idx[i]),

				cl_data->sensor_sts[i]);

		}

	}



	cancel_delayed_work_sync(&cl_data->work_buffer);

	amd_sfh_clear_intr(mp2);

}



int amd_sfh_hid_client_init(struct amd_mp2_dev *privdata)

{

	struct amd_input_data *in_data = &privdata->in_data;

	struct amdtp_cl_data *cl_data = privdata->cl_data;

	struct amd_mp2_ops *mp2_ops = privdata->mp2_ops;

	struct amd_mp2_sensor_info info;

	struct request_list *req_list;

	struct device *dev;

	u32 feature_report_size;

	u32 input_report_size;

	int rc, i, status;

	u8 cl_idx;



	req_list = &cl_data->req_list;

	dev = &privdata->pdev->dev;

	amd_sfh_set_desc_ops(mp2_ops);



	mp2_ops->suspend = amd_sfh_suspend;

	mp2_ops->resume = amd_sfh_resume;



	cl_data->num_hid_devices = amd_mp2_get_sensor_num(privdata, &cl_data->sensor_idx[0]);

	if (cl_data->num_hid_devices == 0)

		return -ENODEV;



	INIT_DELAYED_WORK(&cl_data->work, amd_sfh_work);

	INIT_DELAYED_WORK(&cl_data->work_buffer, amd_sfh_work_buffer);

	INIT_LIST_HEAD(&req_list.list);

	INIT_LIST_HEAD(&req_list->list);

	cl_data->in_data = in_data;



	for (i = 0; i < cl_data->num_hid_devices; i++) {
@@ -187,17 +241,17 @@ int amd_sfh_hid_client_init(struct amd_mp2_dev *privdata) 
		cl_data->sensor_requested_cnt[i] = 0;

		cl_data->cur_hid_dev = i;

		cl_idx = cl_data->sensor_idx[i];

		cl_data->report_descr_sz[i] = get_descr_sz(cl_idx, descr_size);

		cl_data->report_descr_sz[i] = mp2_ops->get_desc_sz(cl_idx, descr_size);

		if (!cl_data->report_descr_sz[i]) {

			rc = -EINVAL;

			goto cleanup;

		}

		feature_report_size = get_descr_sz(cl_idx, feature_size);

		feature_report_size = mp2_ops->get_desc_sz(cl_idx, feature_size);

		if (!feature_report_size) {

			rc = -EINVAL;

			goto cleanup;

		}

		input_report_size =  get_descr_sz(cl_idx, input_size);

		input_report_size =  mp2_ops->get_desc_sz(cl_idx, input_size);

		if (!input_report_size) {

			rc = -EINVAL;

			goto cleanup;
@@ -222,17 +276,17 @@ int amd_sfh_hid_client_init(struct amd_mp2_dev *privdata) 
			rc = -ENOMEM;

			goto cleanup;

		}

		rc = get_report_descriptor(cl_idx, cl_data->report_descr[i]);

		rc = mp2_ops->get_rep_desc(cl_idx, cl_data->report_descr[i]);

		if (rc)

			return rc;

		privdata->mp2_ops->start(privdata, info);

		mp2_ops->start(privdata, info);

		status = amd_sfh_wait_for_response

				(privdata, cl_data->sensor_idx[i], SENSOR_ENABLED);

		if (status == SENSOR_ENABLED) {

			cl_data->sensor_sts[i] = SENSOR_ENABLED;

			rc = amdtp_hid_probe(cl_data->cur_hid_dev, cl_data);

			if (rc) {

				privdata->mp2_ops->stop(privdata, cl_data->sensor_idx[i]);

				mp2_ops->stop(privdata, cl_data->sensor_idx[i]);

				status = amd_sfh_wait_for_response

					(privdata, cl_data->sensor_idx[i], SENSOR_DISABLED);

				if (status != SENSOR_ENABLED)
@@ -248,8 +302,7 @@ int amd_sfh_hid_client_init(struct amd_mp2_dev *privdata) 
			cl_data->sensor_idx[i], get_sensor_name(cl_data->sensor_idx[i]),

			cl_data->sensor_sts[i]);

	}

	if (privdata->mp2_ops->discovery_status &&

	    privdata->mp2_ops->discovery_status(privdata) == 0) {

	if (mp2_ops->discovery_status && mp2_ops->discovery_status(privdata) == 0) {

		amd_sfh_hid_client_deinit(privdata);

		for (i = 0; i < cl_data->num_hid_devices; i++) {

			devm_kfree(dev, cl_data->feature_report[i]);

drivers/hid/amd-sfh-hid/amd_sfh_common.h

0 → 100644
+76 −0
Original line number Diff line number Diff line 
/* SPDX-License-Identifier: GPL-2.0-or-later */

/*

 * AMD MP2 common macros and structures

 *

 * Copyright (c) 2022, Advanced Micro Devices, Inc.

 * All Rights Reserved.

 *

 * Author: Basavaraj Natikar <Basavaraj.Natikar@amd.com>

 */

#ifndef AMD_SFH_COMMON_H

#define AMD_SFH_COMMON_H



#include <linux/pci.h>

#include "amd_sfh_hid.h"



#define PCI_DEVICE_ID_AMD_MP2		0x15E4

#define PCI_DEVICE_ID_AMD_MP2_1_1	0x164A



#define AMD_C2P_MSG(regno) (0x10500 + ((regno) * 4))

#define AMD_P2C_MSG(regno) (0x10680 + ((regno) * 4))



#define SENSOR_ENABLED			4

#define SENSOR_DISABLED			5



#define AMD_SFH_IDLE_LOOP		200



enum cmd_id {

	NO_OP,

	ENABLE_SENSOR,

	DISABLE_SENSOR,

	STOP_ALL_SENSORS = 8,

};



struct amd_mp2_sensor_info {

	u8 sensor_idx;

	u32 period;

	dma_addr_t dma_address;

};



struct amd_mp2_dev {

	struct pci_dev *pdev;

	struct amdtp_cl_data *cl_data;

	void __iomem *mmio;

	void __iomem *vsbase;

	const struct amd_sfh1_1_ops *sfh1_1_ops;

	struct amd_mp2_ops *mp2_ops;

	struct amd_input_data in_data;

	/* mp2 active control status */

	u32 mp2_acs;

};



struct amd_mp2_ops {

	void (*start)(struct amd_mp2_dev *privdata, struct amd_mp2_sensor_info info);

	void (*stop)(struct amd_mp2_dev *privdata, u16 sensor_idx);

	void (*stop_all)(struct amd_mp2_dev *privdata);

	int (*response)(struct amd_mp2_dev *mp2, u8 sid, u32 sensor_sts);

	void (*clear_intr)(struct amd_mp2_dev *privdata);

	int (*init_intr)(struct amd_mp2_dev *privdata);

	int (*discovery_status)(struct amd_mp2_dev *privdata);

	void (*suspend)(struct amd_mp2_dev *mp2);

	void (*resume)(struct amd_mp2_dev *mp2);

	void (*remove)(void *privdata);

	int (*get_rep_desc)(int sensor_idx, u8 rep_desc[]);

	u32 (*get_desc_sz)(int sensor_idx, int descriptor_name);

	u8 (*get_feat_rep)(int sensor_idx, int report_id, u8 *feature_report);

	u8 (*get_in_rep)(u8 current_index, int sensor_idx, int report_id,

			 struct amd_input_data *in_data);

};



void amd_sfh_work(struct work_struct *work);

void amd_sfh_work_buffer(struct work_struct *work);

void amd_sfh_clear_intr_v2(struct amd_mp2_dev *privdata);

int amd_sfh_irq_init_v2(struct amd_mp2_dev *privdata);

void amd_sfh_clear_intr(struct amd_mp2_dev *privdata);

int amd_sfh_irq_init(struct amd_mp2_dev *privdata);

#endif

drivers/hid/amd-sfh-hid/amd_sfh_hid.c

+8 −4
Original line number Diff line number Diff line
@@ -101,12 +101,16 @@ static int amdtp_wait_for_response(struct hid_device *hid) 


void amdtp_hid_wakeup(struct hid_device *hid)

{

	struct amdtp_hid_data *hid_data = hid->driver_data;

	struct amdtp_cl_data *cli_data = hid_data->cli_data;

	struct amdtp_hid_data *hid_data;

	struct amdtp_cl_data *cli_data;



	if (hid) {

		hid_data = hid->driver_data;

		cli_data = hid_data->cli_data;

		cli_data->request_done[cli_data->cur_hid_dev] = true;

		wake_up_interruptible(&hid_data->hid_wait);

	}

}



static struct hid_ll_driver amdtp_hid_ll_driver = {

	.parse	=	amdtp_hid_parse,

drivers/hid/amd-sfh-hid/amd_sfh_hid.h

+10 −2
Original line number Diff line number Diff line
@@ -15,6 +15,15 @@ 
#define AMD_SFH_HID_VENDOR	0x1022

#define AMD_SFH_HID_PRODUCT	0x0001



struct request_list {

	struct hid_device *hid;

	struct list_head list;

	u8 report_id;

	u8 sensor_idx;

	u8 report_type;

	u8 current_index;

};



struct amd_input_data {

	u32 *sensor_virt_addr[MAX_HID_DEVICES];

	u8 *input_report[MAX_HID_DEVICES];
@@ -43,6 +52,7 @@ struct amdtp_cl_data { 
	struct amd_input_data *in_data;

	struct delayed_work work;

	struct delayed_work work_buffer;

	struct request_list req_list;

};



/**
@@ -69,6 +79,4 @@ void amdtp_hid_remove(struct amdtp_cl_data *cli_data); 
int amd_sfh_get_report(struct hid_device *hid, int report_id, int report_type);

void amd_sfh_set_report(struct hid_device *hid, int report_id, int report_type);

void amdtp_hid_wakeup(struct hid_device *hid);

u8 get_input_report(u8 current_index, int sensor_idx, int report_id,

		    struct amd_input_data *in_data);

#endif