1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  *  AMD SFH Client Layer
4  *  Copyright 2020 Advanced Micro Devices, Inc.
5  *  Authors: Nehal Bakulchandra Shah <Nehal-Bakulchandra.Shah@amd.com>
6  *	     Sandeep Singh <Sandeep.singh@amd.com>
7  */
8 
9 #include <linux/dma-mapping.h>
10 #include <linux/hid.h>
11 #include <linux/list.h>
12 #include <linux/slab.h>
13 #include <linux/workqueue.h>
14 #include <linux/errno.h>
15 
16 #include "hid_descriptor/amd_sfh_hid_desc.h"
17 #include "amd_sfh_pcie.h"
18 #include "amd_sfh_hid.h"
19 
20 #define AMD_SFH_IDLE_LOOP	200
21 
22 struct request_list {
23 	struct hid_device *hid;
24 	struct list_head list;
25 	u8 report_id;
26 	u8 sensor_idx;
27 	u8 report_type;
28 	u8 current_index;
29 };
30 
31 static struct request_list req_list;
32 
33 void amd_sfh_set_report(struct hid_device *hid, int report_id,
34 			int report_type)
35 {
36 	struct amdtp_hid_data *hid_data = hid->driver_data;
37 	struct amdtp_cl_data *cli_data = hid_data->cli_data;
38 	int i;
39 
40 	for (i = 0; i < cli_data->num_hid_devices; i++) {
41 		if (cli_data->hid_sensor_hubs[i] == hid) {
42 			cli_data->cur_hid_dev = i;
43 			break;
44 		}
45 	}
46 	amdtp_hid_wakeup(hid);
47 }
48 
49 int amd_sfh_get_report(struct hid_device *hid, int report_id, int report_type)
50 {
51 	struct amdtp_hid_data *hid_data = hid->driver_data;
52 	struct amdtp_cl_data *cli_data = hid_data->cli_data;
53 	int i;
54 
55 	for (i = 0; i < cli_data->num_hid_devices; i++) {
56 		if (cli_data->hid_sensor_hubs[i] == hid) {
57 			struct request_list *new = kzalloc(sizeof(*new), GFP_KERNEL);
58 
59 			if (!new)
60 				return -ENOMEM;
61 
62 			new->current_index = i;
63 			new->sensor_idx = cli_data->sensor_idx[i];
64 			new->hid = hid;
65 			new->report_type = report_type;
66 			new->report_id = report_id;
67 			cli_data->report_id[i] = report_id;
68 			cli_data->request_done[i] = false;
69 			list_add(&new->list, &req_list.list);
70 			break;
71 		}
72 	}
73 	schedule_delayed_work(&cli_data->work, 0);
74 	return 0;
75 }
76 
77 static void amd_sfh_work(struct work_struct *work)
78 {
79 	struct amdtp_cl_data *cli_data = container_of(work, struct amdtp_cl_data, work.work);
80 	struct amd_input_data *in_data = cli_data->in_data;
81 	struct request_list *req_node;
82 	u8 current_index, sensor_index;
83 	u8 report_id, node_type;
84 	u8 report_size = 0;
85 
86 	req_node = list_last_entry(&req_list.list, struct request_list, list);
87 	list_del(&req_node->list);
88 	current_index = req_node->current_index;
89 	sensor_index = req_node->sensor_idx;
90 	report_id = req_node->report_id;
91 	node_type = req_node->report_type;
92 	kfree(req_node);
93 
94 	if (node_type == HID_FEATURE_REPORT) {
95 		report_size = get_feature_report(sensor_index, report_id,
96 						 cli_data->feature_report[current_index]);
97 		if (report_size)
98 			hid_input_report(cli_data->hid_sensor_hubs[current_index],
99 					 cli_data->report_type[current_index],
100 					 cli_data->feature_report[current_index], report_size, 0);
101 		else
102 			pr_err("AMDSFH: Invalid report size\n");
103 
104 	} else if (node_type == HID_INPUT_REPORT) {
105 		report_size = get_input_report(current_index, sensor_index, report_id, in_data);
106 		if (report_size)
107 			hid_input_report(cli_data->hid_sensor_hubs[current_index],
108 					 cli_data->report_type[current_index],
109 					 in_data->input_report[current_index], report_size, 0);
110 		else
111 			pr_err("AMDSFH: Invalid report size\n");
112 	}
113 	cli_data->cur_hid_dev = current_index;
114 	cli_data->sensor_requested_cnt[current_index] = 0;
115 	amdtp_hid_wakeup(cli_data->hid_sensor_hubs[current_index]);
116 }
117 
118 static void amd_sfh_work_buffer(struct work_struct *work)
119 {
120 	struct amdtp_cl_data *cli_data = container_of(work, struct amdtp_cl_data, work_buffer.work);
121 	struct amd_input_data *in_data = cli_data->in_data;
122 	u8 report_size;
123 	int i;
124 
125 	for (i = 0; i < cli_data->num_hid_devices; i++) {
126 		report_size = get_input_report(i, cli_data->sensor_idx[i], cli_data->report_id[i],
127 					       in_data);
128 		hid_input_report(cli_data->hid_sensor_hubs[i], HID_INPUT_REPORT,
129 				 in_data->input_report[i], report_size, 0);
130 	}
131 	schedule_delayed_work(&cli_data->work_buffer, msecs_to_jiffies(AMD_SFH_IDLE_LOOP));
132 }
133 
134 int amd_sfh_hid_client_init(struct amd_mp2_dev *privdata)
135 {
136 	struct amd_input_data *in_data = &privdata->in_data;
137 	struct amdtp_cl_data *cl_data = privdata->cl_data;
138 	struct amd_mp2_sensor_info info;
139 	struct device *dev;
140 	u32 feature_report_size;
141 	u32 input_report_size;
142 	u8 cl_idx;
143 	int rc, i;
144 
145 	dev = &privdata->pdev->dev;
146 
147 	cl_data->num_hid_devices = amd_mp2_get_sensor_num(privdata, &cl_data->sensor_idx[0]);
148 
149 	INIT_DELAYED_WORK(&cl_data->work, amd_sfh_work);
150 	INIT_DELAYED_WORK(&cl_data->work_buffer, amd_sfh_work_buffer);
151 	INIT_LIST_HEAD(&req_list.list);
152 	cl_data->in_data = in_data;
153 
154 	for (i = 0; i < cl_data->num_hid_devices; i++) {
155 		in_data->sensor_virt_addr[i] = dma_alloc_coherent(dev, sizeof(int) * 8,
156 								  &cl_data->sensor_dma_addr[i],
157 								  GFP_KERNEL);
158 		cl_data->sensor_sts[i] = 0;
159 		cl_data->sensor_requested_cnt[i] = 0;
160 		cl_data->cur_hid_dev = i;
161 		cl_idx = cl_data->sensor_idx[i];
162 		cl_data->report_descr_sz[i] = get_descr_sz(cl_idx, descr_size);
163 		if (!cl_data->report_descr_sz[i]) {
164 			rc = -EINVAL;
165 			goto cleanup;
166 		}
167 		feature_report_size = get_descr_sz(cl_idx, feature_size);
168 		if (!feature_report_size) {
169 			rc = -EINVAL;
170 			goto cleanup;
171 		}
172 		input_report_size =  get_descr_sz(cl_idx, input_size);
173 		if (!input_report_size) {
174 			rc = -EINVAL;
175 			goto cleanup;
176 		}
177 		cl_data->feature_report[i] = devm_kzalloc(dev, feature_report_size, GFP_KERNEL);
178 		if (!cl_data->feature_report[i]) {
179 			rc = -ENOMEM;
180 			goto cleanup;
181 		}
182 		in_data->input_report[i] = devm_kzalloc(dev, input_report_size, GFP_KERNEL);
183 		if (!in_data->input_report[i]) {
184 			rc = -ENOMEM;
185 			goto cleanup;
186 		}
187 		info.period = msecs_to_jiffies(AMD_SFH_IDLE_LOOP);
188 		info.sensor_idx = cl_idx;
189 		info.dma_address = cl_data->sensor_dma_addr[i];
190 
191 		cl_data->report_descr[i] =
192 			devm_kzalloc(dev, cl_data->report_descr_sz[i], GFP_KERNEL);
193 		if (!cl_data->report_descr[i]) {
194 			rc = -ENOMEM;
195 			goto cleanup;
196 		}
197 		rc = get_report_descriptor(cl_idx, cl_data->report_descr[i]);
198 		if (rc)
199 			return rc;
200 		rc = amdtp_hid_probe(cl_data->cur_hid_dev, cl_data);
201 		if (rc)
202 			return rc;
203 		privdata->mp2_ops->start(privdata, info);
204 		cl_data->sensor_sts[i] = 1;
205 	}
206 	schedule_delayed_work(&cl_data->work_buffer, msecs_to_jiffies(AMD_SFH_IDLE_LOOP));
207 	return 0;
208 
209 cleanup:
210 	for (i = 0; i < cl_data->num_hid_devices; i++) {
211 		if (in_data->sensor_virt_addr[i]) {
212 			dma_free_coherent(&privdata->pdev->dev, 8 * sizeof(int),
213 					  in_data->sensor_virt_addr[i],
214 					  cl_data->sensor_dma_addr[i]);
215 		}
216 		devm_kfree(dev, cl_data->feature_report[i]);
217 		devm_kfree(dev, in_data->input_report[i]);
218 		devm_kfree(dev, cl_data->report_descr[i]);
219 	}
220 	return rc;
221 }
222 
223 int amd_sfh_hid_client_deinit(struct amd_mp2_dev *privdata)
224 {
225 	struct amdtp_cl_data *cl_data = privdata->cl_data;
226 	struct amd_input_data *in_data = cl_data->in_data;
227 	int i;
228 
229 	for (i = 0; i < cl_data->num_hid_devices; i++)
230 		privdata->mp2_ops->stop(privdata, i);
231 
232 	cancel_delayed_work_sync(&cl_data->work);
233 	cancel_delayed_work_sync(&cl_data->work_buffer);
234 	amdtp_hid_remove(cl_data);
235 
236 	for (i = 0; i < cl_data->num_hid_devices; i++) {
237 		if (in_data->sensor_virt_addr[i]) {
238 			dma_free_coherent(&privdata->pdev->dev, 8 * sizeof(int),
239 					  in_data->sensor_virt_addr[i],
240 					  cl_data->sensor_dma_addr[i]);
241 		}
242 	}
243 	return 0;
244 }
245