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

   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 }