amd_sfh_hid.c

  1// SPDX-License-Identifier: GPL-2.0-or-later
  2/*
  3 * AMD MP2 Sensors transport driver
  4 *
  5 * Copyright 2020-2021 Advanced Micro Devices, Inc.
  6 * Authors: Nehal Bakulchandra Shah <Nehal-bakulchandra.shah@amd.com>
  7 *	    Sandeep Singh <sandeep.singh@amd.com>
  8 *	    Basavaraj Natikar <Basavaraj.Natikar@amd.com>
  9 */
 10#include <linux/hid.h>
 11#include <linux/wait.h>
 12#include <linux/sched.h>
 13
 14#include "amd_sfh_hid.h"
 15#include "amd_sfh_pcie.h"
 16
 17#define AMD_SFH_RESPONSE_TIMEOUT	1500
 18
 19/**
 20 * amdtp_hid_parse() - hid-core .parse() callback
 21 * @hid:	hid device instance
 22 *
 23 * This function gets called during call to hid_add_device
 24 *
 25 * Return: 0 on success and non zero on error
 26 */
 27static int amdtp_hid_parse(struct hid_device *hid)
 28{
 29	struct amdtp_hid_data *hid_data = hid->driver_data;
 30	struct amdtp_cl_data *cli_data = hid_data->cli_data;
 31
 32	return hid_parse_report(hid, cli_data->report_descr[hid_data->index],
 33			      cli_data->report_descr_sz[hid_data->index]);
 34}
 35
 36/* Empty callbacks with success return code */
 37static int amdtp_hid_start(struct hid_device *hid)
 38{
 39	return 0;
 40}
 41
 42static void amdtp_hid_stop(struct hid_device *hid)
 43{
 44}
 45
 46static int amdtp_hid_open(struct hid_device *hid)
 47{
 48	return 0;
 49}
 50
 51static void amdtp_hid_close(struct hid_device *hid)
 52{
 53}
 54
 55static int amdtp_raw_request(struct hid_device *hdev, u8 reportnum,
 56			     u8 *buf, size_t len, u8 rtype, int reqtype)
 57{
 58	return 0;
 59}
 60
 61static void amdtp_hid_request(struct hid_device *hid, struct hid_report *rep, int reqtype)
 62{
 63	int rc;
 64
 65	switch (reqtype) {
 66	case HID_REQ_GET_REPORT:
 67		rc = amd_sfh_get_report(hid, rep->id, rep->type);
 68		if (rc)
 69			dev_err(&hid->dev, "AMDSFH  get report error\n");
 70		break;
 71	case HID_REQ_SET_REPORT:
 72		amd_sfh_set_report(hid, rep->id, reqtype);
 73		break;
 74	default:
 75		break;
 76	}
 77}
 78
 79static int amdtp_wait_for_response(struct hid_device *hid)
 80{
 81	struct amdtp_hid_data *hid_data =  hid->driver_data;
 82	struct amdtp_cl_data *cli_data = hid_data->cli_data;
 83	int i, ret = 0;
 84
 85	for (i = 0; i < cli_data->num_hid_devices; i++) {
 86		if (cli_data->hid_sensor_hubs[i] == hid)
 87			break;
 88	}
 89
 90	if (!cli_data->request_done[i])
 91		ret = wait_event_interruptible_timeout(hid_data->hid_wait,
 92						       cli_data->request_done[i],
 93						       msecs_to_jiffies(AMD_SFH_RESPONSE_TIMEOUT));
 94	if (ret == -ERESTARTSYS)
 95		return -ERESTARTSYS;
 96	else if (ret < 0)
 97		return -ETIMEDOUT;
 98	else
 99		return 0;
100}
101
102void amdtp_hid_wakeup(struct hid_device *hid)
103{
104	struct amdtp_hid_data *hid_data;
105	struct amdtp_cl_data *cli_data;
106
107	if (hid) {
108		hid_data = hid->driver_data;
109		cli_data = hid_data->cli_data;
110		cli_data->request_done[cli_data->cur_hid_dev] = true;
111		wake_up_interruptible(&hid_data->hid_wait);
112	}
113}
114
115static const struct hid_ll_driver amdtp_hid_ll_driver = {
116	.parse	=	amdtp_hid_parse,
117	.start	=	amdtp_hid_start,
118	.stop	=	amdtp_hid_stop,
119	.open	=	amdtp_hid_open,
120	.close	=	amdtp_hid_close,
121	.request  =	amdtp_hid_request,
122	.wait	=	amdtp_wait_for_response,
123	.raw_request  =	amdtp_raw_request,
124};
125
126int amdtp_hid_probe(u32 cur_hid_dev, struct amdtp_cl_data *cli_data)
127{
128	struct amd_mp2_dev *mp2 = container_of(cli_data->in_data, struct amd_mp2_dev, in_data);
129	struct device *dev = &mp2->pdev->dev;
130	struct hid_device *hid;
131	struct amdtp_hid_data *hid_data;
132	int rc;
133
134	hid = hid_allocate_device();
135	if (IS_ERR(hid))
136		return PTR_ERR(hid);
137
138	hid_data = kzalloc(sizeof(*hid_data), GFP_KERNEL);
139	if (!hid_data) {
140		rc = -ENOMEM;
141		goto err_hid_data;
142	}
143
144	hid->ll_driver = &amdtp_hid_ll_driver;
145	hid_data->index = cur_hid_dev;
146	hid_data->cli_data = cli_data;
147	init_waitqueue_head(&hid_data->hid_wait);
148
149	hid->driver_data = hid_data;
150	cli_data->hid_sensor_hubs[cur_hid_dev] = hid;
151	strscpy(hid->phys, dev->driver ? dev->driver->name : dev_name(dev),
152		sizeof(hid->phys));
153	hid->bus = BUS_AMD_SFH;
154	hid->vendor = AMD_SFH_HID_VENDOR;
155	hid->product = AMD_SFH_HID_PRODUCT;
156	snprintf(hid->name, sizeof(hid->name), "%s %04X:%04X", "hid-amdsfh",
157		 hid->vendor, hid->product);
158
159	rc = hid_add_device(hid);
160	if (rc)
161		goto err_hid_device;
162	return 0;
163
164err_hid_device:
165	kfree(hid_data);
166err_hid_data:
167	hid_destroy_device(hid);
168	return rc;
169}
170
171void amdtp_hid_remove(struct amdtp_cl_data *cli_data)
172{
173	int i;
174	struct amdtp_hid_data *hid_data;
175
176	for (i = 0; i < cli_data->num_hid_devices; ++i) {
177		if (cli_data->hid_sensor_hubs[i]) {
178			hid_data = cli_data->hid_sensor_hubs[i]->driver_data;
179			hid_destroy_device(cli_data->hid_sensor_hubs[i]);
180			kfree(hid_data);
181			cli_data->hid_sensor_hubs[i] = NULL;
182		}
183	}
184}