1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * AMD SFH Client Layer 4 * Copyright 2020-2021 Advanced Micro Devices, Inc. 5 * Authors: Nehal Bakulchandra Shah <Nehal-Bakulchandra.Shah@amd.com> 6 * Sandeep Singh <Sandeep.singh@amd.com> 7 * Basavaraj Natikar <Basavaraj.Natikar@amd.com> 8 */ 9 10 #include <linux/dma-mapping.h> 11 #include <linux/hid.h> 12 #include <linux/list.h> 13 #include <linux/slab.h> 14 #include <linux/workqueue.h> 15 #include <linux/errno.h> 16 17 #include "hid_descriptor/amd_sfh_hid_desc.h" 18 #include "amd_sfh_pcie.h" 19 #include "amd_sfh_hid.h" 20 21 void amd_sfh_set_report(struct hid_device *hid, int report_id, 22 int report_type) 23 { 24 struct amdtp_hid_data *hid_data = hid->driver_data; 25 struct amdtp_cl_data *cli_data = hid_data->cli_data; 26 int i; 27 28 for (i = 0; i < cli_data->num_hid_devices; i++) { 29 if (cli_data->hid_sensor_hubs[i] == hid) { 30 cli_data->cur_hid_dev = i; 31 break; 32 } 33 } 34 amdtp_hid_wakeup(hid); 35 } 36 37 int amd_sfh_get_report(struct hid_device *hid, int report_id, int report_type) 38 { 39 struct amdtp_hid_data *hid_data = hid->driver_data; 40 struct amdtp_cl_data *cli_data = hid_data->cli_data; 41 struct request_list *req_list = &cli_data->req_list; 42 struct amd_input_data *in_data = cli_data->in_data; 43 struct amd_mp2_dev *mp2; 44 int i; 45 46 mp2 = container_of(in_data, struct amd_mp2_dev, in_data); 47 guard(mutex)(&mp2->lock); 48 for (i = 0; i < cli_data->num_hid_devices; i++) { 49 if (cli_data->hid_sensor_hubs[i] == hid) { 50 struct request_list *new = kzalloc(sizeof(*new), GFP_KERNEL); 51 52 if (!new) 53 return -ENOMEM; 54 55 new->current_index = i; 56 new->sensor_idx = cli_data->sensor_idx[i]; 57 new->hid = hid; 58 new->report_type = report_type; 59 new->report_id = report_id; 60 cli_data->report_id[i] = report_id; 61 cli_data->request_done[i] = false; 62 list_add(&new->list, &req_list->list); 63 break; 64 } 65 } 66 schedule_delayed_work(&cli_data->work, 0); 67 return 0; 68 } 69 70 void amd_sfh_work(struct work_struct *work) 71 { 72 struct amdtp_cl_data *cli_data = container_of(work, struct amdtp_cl_data, work.work); 73 struct request_list *req_list = &cli_data->req_list; 74 struct amd_input_data *in_data = cli_data->in_data; 75 struct request_list *req_node; 76 u8 current_index, sensor_index; 77 struct amd_mp2_ops *mp2_ops; 78 struct amd_mp2_dev *mp2; 79 u8 report_id, node_type; 80 u8 report_size = 0; 81 82 mp2 = container_of(in_data, struct amd_mp2_dev, in_data); 83 guard(mutex)(&mp2->lock); 84 req_node = list_last_entry(&req_list->list, struct request_list, list); 85 list_del(&req_node->list); 86 current_index = req_node->current_index; 87 sensor_index = req_node->sensor_idx; 88 report_id = req_node->report_id; 89 node_type = req_node->report_type; 90 kfree(req_node); 91 92 mp2_ops = mp2->mp2_ops; 93 if (node_type == HID_FEATURE_REPORT) { 94 report_size = mp2_ops->get_feat_rep(sensor_index, report_id, 95 cli_data->feature_report[current_index]); 96 if (report_size) 97 hid_input_report(cli_data->hid_sensor_hubs[current_index], 98 cli_data->report_type[current_index], 99 cli_data->feature_report[current_index], report_size, 0); 100 else 101 pr_err("AMDSFH: Invalid report size\n"); 102 103 } else if (node_type == HID_INPUT_REPORT) { 104 report_size = mp2_ops->get_in_rep(current_index, sensor_index, report_id, in_data); 105 if (report_size) 106 hid_input_report(cli_data->hid_sensor_hubs[current_index], 107 cli_data->report_type[current_index], 108 in_data->input_report[current_index], report_size, 0); 109 else 110 pr_err("AMDSFH: Invalid report size\n"); 111 } 112 cli_data->cur_hid_dev = current_index; 113 cli_data->sensor_requested_cnt[current_index] = 0; 114 amdtp_hid_wakeup(cli_data->hid_sensor_hubs[current_index]); 115 if (!list_empty(&req_list->list)) 116 schedule_delayed_work(&cli_data->work, 0); 117 } 118 119 void amd_sfh_work_buffer(struct work_struct *work) 120 { 121 struct amdtp_cl_data *cli_data = container_of(work, struct amdtp_cl_data, work_buffer.work); 122 struct amd_input_data *in_data = cli_data->in_data; 123 struct amd_mp2_dev *mp2; 124 u8 report_size; 125 int i; 126 127 mp2 = container_of(in_data, struct amd_mp2_dev, in_data); 128 guard(mutex)(&mp2->lock); 129 for (i = 0; i < cli_data->num_hid_devices; i++) { 130 if (cli_data->sensor_sts[i] == SENSOR_ENABLED) { 131 report_size = mp2->mp2_ops->get_in_rep(i, cli_data->sensor_idx[i], 132 cli_data->report_id[i], in_data); 133 hid_input_report(cli_data->hid_sensor_hubs[i], HID_INPUT_REPORT, 134 in_data->input_report[i], report_size, 0); 135 } 136 } 137 schedule_delayed_work(&cli_data->work_buffer, msecs_to_jiffies(AMD_SFH_IDLE_LOOP)); 138 } 139 140 static u32 amd_sfh_wait_for_response(struct amd_mp2_dev *mp2, u8 sid, u32 sensor_sts) 141 { 142 if (mp2->mp2_ops->response) 143 sensor_sts = mp2->mp2_ops->response(mp2, sid, sensor_sts); 144 145 return sensor_sts; 146 } 147 148 static const char *get_sensor_name(int idx) 149 { 150 switch (idx) { 151 case accel_idx: 152 return "accelerometer"; 153 case gyro_idx: 154 return "gyroscope"; 155 case mag_idx: 156 return "magnetometer"; 157 case op_idx: 158 return "operating-mode"; 159 case als_idx: 160 case ACS_IDX: /* ambient color sensor */ 161 return "ALS"; 162 case HPD_IDX: 163 return "HPD"; 164 default: 165 return "unknown sensor type"; 166 } 167 } 168 169 static void amd_sfh_resume(struct amd_mp2_dev *mp2) 170 { 171 struct amdtp_cl_data *cl_data = mp2->cl_data; 172 struct amd_mp2_sensor_info info; 173 int i, status; 174 175 for (i = 0; i < cl_data->num_hid_devices; i++) { 176 if (cl_data->sensor_sts[i] == SENSOR_DISABLED) { 177 info.period = AMD_SFH_IDLE_LOOP; 178 info.sensor_idx = cl_data->sensor_idx[i]; 179 info.dma_address = cl_data->sensor_dma_addr[i]; 180 mp2->mp2_ops->start(mp2, info); 181 status = amd_sfh_wait_for_response 182 (mp2, cl_data->sensor_idx[i], SENSOR_ENABLED); 183 if (status == SENSOR_ENABLED) 184 cl_data->sensor_sts[i] = SENSOR_ENABLED; 185 dev_dbg(&mp2->pdev->dev, "resume sid 0x%x (%s) status 0x%x\n", 186 cl_data->sensor_idx[i], get_sensor_name(cl_data->sensor_idx[i]), 187 cl_data->sensor_sts[i]); 188 } 189 } 190 191 schedule_delayed_work(&cl_data->work_buffer, msecs_to_jiffies(AMD_SFH_IDLE_LOOP)); 192 amd_sfh_clear_intr(mp2); 193 } 194 195 static void amd_sfh_suspend(struct amd_mp2_dev *mp2) 196 { 197 struct amdtp_cl_data *cl_data = mp2->cl_data; 198 int i, status; 199 200 for (i = 0; i < cl_data->num_hid_devices; i++) { 201 if (cl_data->sensor_idx[i] != HPD_IDX && 202 cl_data->sensor_sts[i] == SENSOR_ENABLED) { 203 mp2->mp2_ops->stop(mp2, cl_data->sensor_idx[i]); 204 status = amd_sfh_wait_for_response 205 (mp2, cl_data->sensor_idx[i], SENSOR_DISABLED); 206 if (status != SENSOR_ENABLED) 207 cl_data->sensor_sts[i] = SENSOR_DISABLED; 208 dev_dbg(&mp2->pdev->dev, "suspend sid 0x%x (%s) status 0x%x\n", 209 cl_data->sensor_idx[i], get_sensor_name(cl_data->sensor_idx[i]), 210 cl_data->sensor_sts[i]); 211 } 212 } 213 214 cancel_delayed_work_sync(&cl_data->work_buffer); 215 amd_sfh_clear_intr(mp2); 216 } 217 218 int amd_sfh_hid_client_init(struct amd_mp2_dev *privdata) 219 { 220 struct amd_input_data *in_data = &privdata->in_data; 221 struct amdtp_cl_data *cl_data = privdata->cl_data; 222 struct amd_mp2_ops *mp2_ops = privdata->mp2_ops; 223 struct amd_mp2_sensor_info info; 224 struct request_list *req_list; 225 struct device *dev; 226 u32 feature_report_size; 227 u32 input_report_size; 228 int rc, i; 229 u8 cl_idx; 230 231 req_list = &cl_data->req_list; 232 dev = &privdata->pdev->dev; 233 amd_sfh_set_desc_ops(mp2_ops); 234 235 mp2_ops->suspend = amd_sfh_suspend; 236 mp2_ops->resume = amd_sfh_resume; 237 238 cl_data->num_hid_devices = amd_mp2_get_sensor_num(privdata, &cl_data->sensor_idx[0]); 239 if (cl_data->num_hid_devices == 0) 240 return -ENODEV; 241 cl_data->is_any_sensor_enabled = false; 242 243 INIT_DELAYED_WORK(&cl_data->work, amd_sfh_work); 244 INIT_DELAYED_WORK(&cl_data->work_buffer, amd_sfh_work_buffer); 245 INIT_LIST_HEAD(&req_list->list); 246 cl_data->in_data = in_data; 247 248 for (i = 0; i < cl_data->num_hid_devices; i++) { 249 in_data->sensor_virt_addr[i] = dmam_alloc_coherent(dev, sizeof(int) * 8, 250 &cl_data->sensor_dma_addr[i], 251 GFP_KERNEL); 252 if (!in_data->sensor_virt_addr[i]) { 253 rc = -ENOMEM; 254 goto cleanup; 255 } 256 257 if (cl_data->sensor_idx[i] == op_idx) { 258 info.period = AMD_SFH_IDLE_LOOP; 259 info.sensor_idx = cl_data->sensor_idx[i]; 260 info.dma_address = cl_data->sensor_dma_addr[i]; 261 mp2_ops->start(privdata, info); 262 cl_data->sensor_sts[i] = amd_sfh_wait_for_response(privdata, 263 cl_data->sensor_idx[i], 264 SENSOR_ENABLED); 265 if (cl_data->sensor_sts[i] == SENSOR_ENABLED) 266 cl_data->is_any_sensor_enabled = true; 267 continue; 268 } 269 270 cl_data->sensor_sts[i] = SENSOR_DISABLED; 271 cl_data->sensor_requested_cnt[i] = 0; 272 cl_data->cur_hid_dev = i; 273 cl_idx = cl_data->sensor_idx[i]; 274 cl_data->report_descr_sz[i] = mp2_ops->get_desc_sz(cl_idx, descr_size); 275 if (!cl_data->report_descr_sz[i]) { 276 rc = -EINVAL; 277 goto cleanup; 278 } 279 feature_report_size = mp2_ops->get_desc_sz(cl_idx, feature_size); 280 if (!feature_report_size) { 281 rc = -EINVAL; 282 goto cleanup; 283 } 284 input_report_size = mp2_ops->get_desc_sz(cl_idx, input_size); 285 if (!input_report_size) { 286 rc = -EINVAL; 287 goto cleanup; 288 } 289 cl_data->feature_report[i] = devm_kzalloc(dev, feature_report_size, GFP_KERNEL); 290 if (!cl_data->feature_report[i]) { 291 rc = -ENOMEM; 292 goto cleanup; 293 } 294 in_data->input_report[i] = devm_kzalloc(dev, input_report_size, GFP_KERNEL); 295 if (!in_data->input_report[i]) { 296 rc = -ENOMEM; 297 goto cleanup; 298 } 299 info.period = AMD_SFH_IDLE_LOOP; 300 info.sensor_idx = cl_idx; 301 info.dma_address = cl_data->sensor_dma_addr[i]; 302 303 cl_data->report_descr[i] = 304 devm_kzalloc(dev, cl_data->report_descr_sz[i], GFP_KERNEL); 305 if (!cl_data->report_descr[i]) { 306 rc = -ENOMEM; 307 goto cleanup; 308 } 309 rc = mp2_ops->get_rep_desc(cl_idx, cl_data->report_descr[i]); 310 if (rc) 311 goto cleanup; 312 mp2_ops->start(privdata, info); 313 cl_data->sensor_sts[i] = amd_sfh_wait_for_response 314 (privdata, cl_data->sensor_idx[i], SENSOR_ENABLED); 315 316 if (cl_data->sensor_sts[i] == SENSOR_ENABLED) 317 cl_data->is_any_sensor_enabled = true; 318 } 319 320 if (!cl_data->is_any_sensor_enabled || 321 (mp2_ops->discovery_status && mp2_ops->discovery_status(privdata) == 0)) { 322 dev_warn(dev, "Failed to discover, sensors not enabled is %d\n", 323 cl_data->is_any_sensor_enabled); 324 rc = -EOPNOTSUPP; 325 goto cleanup; 326 } 327 328 for (i = 0; i < cl_data->num_hid_devices; i++) { 329 cl_data->cur_hid_dev = i; 330 if (cl_data->sensor_idx[i] == op_idx) { 331 dev_dbg(dev, "sid 0x%x (%s) status 0x%x\n", 332 cl_data->sensor_idx[i], get_sensor_name(cl_data->sensor_idx[i]), 333 cl_data->sensor_sts[i]); 334 continue; 335 } 336 337 if (cl_data->sensor_sts[i] == SENSOR_ENABLED) { 338 rc = amdtp_hid_probe(i, cl_data); 339 if (rc) 340 goto cleanup; 341 } else { 342 cl_data->sensor_sts[i] = SENSOR_DISABLED; 343 } 344 dev_dbg(dev, "sid 0x%x (%s) status 0x%x\n", 345 cl_data->sensor_idx[i], get_sensor_name(cl_data->sensor_idx[i]), 346 cl_data->sensor_sts[i]); 347 } 348 349 schedule_delayed_work(&cl_data->work_buffer, msecs_to_jiffies(AMD_SFH_IDLE_LOOP)); 350 return 0; 351 352 cleanup: 353 amd_sfh_hid_client_deinit(privdata); 354 for (i = 0; i < cl_data->num_hid_devices; i++) { 355 devm_kfree(dev, cl_data->feature_report[i]); 356 devm_kfree(dev, in_data->input_report[i]); 357 devm_kfree(dev, cl_data->report_descr[i]); 358 } 359 return rc; 360 } 361 362 int amd_sfh_hid_client_deinit(struct amd_mp2_dev *privdata) 363 { 364 struct amdtp_cl_data *cl_data = privdata->cl_data; 365 int i, status; 366 367 for (i = 0; i < cl_data->num_hid_devices; i++) { 368 if (cl_data->sensor_sts[i] == SENSOR_ENABLED) { 369 privdata->mp2_ops->stop(privdata, cl_data->sensor_idx[i]); 370 status = amd_sfh_wait_for_response 371 (privdata, cl_data->sensor_idx[i], SENSOR_DISABLED); 372 if (status != SENSOR_ENABLED) 373 cl_data->sensor_sts[i] = SENSOR_DISABLED; 374 dev_dbg(&privdata->pdev->dev, "stopping sid 0x%x (%s) status 0x%x\n", 375 cl_data->sensor_idx[i], get_sensor_name(cl_data->sensor_idx[i]), 376 cl_data->sensor_sts[i]); 377 } 378 } 379 380 cancel_delayed_work_sync(&cl_data->work); 381 cancel_delayed_work_sync(&cl_data->work_buffer); 382 amdtp_hid_remove(cl_data); 383 384 return 0; 385 } 386