Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  *  AMD SFH Client Layer
0004  *  Copyright 2020-2021 Advanced Micro Devices, Inc.
0005  *  Authors: Nehal Bakulchandra Shah <Nehal-Bakulchandra.Shah@amd.com>
0006  *       Sandeep Singh <Sandeep.singh@amd.com>
0007  *       Basavaraj Natikar <Basavaraj.Natikar@amd.com>
0008  */
0009 
0010 #include <linux/dma-mapping.h>
0011 #include <linux/hid.h>
0012 #include <linux/list.h>
0013 #include <linux/slab.h>
0014 #include <linux/workqueue.h>
0015 #include <linux/errno.h>
0016 
0017 #include "hid_descriptor/amd_sfh_hid_desc.h"
0018 #include "amd_sfh_pcie.h"
0019 #include "amd_sfh_hid.h"
0020 
0021 void amd_sfh_set_report(struct hid_device *hid, int report_id,
0022             int report_type)
0023 {
0024     struct amdtp_hid_data *hid_data = hid->driver_data;
0025     struct amdtp_cl_data *cli_data = hid_data->cli_data;
0026     int i;
0027 
0028     for (i = 0; i < cli_data->num_hid_devices; i++) {
0029         if (cli_data->hid_sensor_hubs[i] == hid) {
0030             cli_data->cur_hid_dev = i;
0031             break;
0032         }
0033     }
0034     amdtp_hid_wakeup(hid);
0035 }
0036 
0037 int amd_sfh_get_report(struct hid_device *hid, int report_id, int report_type)
0038 {
0039     struct amdtp_hid_data *hid_data = hid->driver_data;
0040     struct amdtp_cl_data *cli_data = hid_data->cli_data;
0041     struct request_list *req_list = &cli_data->req_list;
0042     int i;
0043 
0044     for (i = 0; i < cli_data->num_hid_devices; i++) {
0045         if (cli_data->hid_sensor_hubs[i] == hid) {
0046             struct request_list *new = kzalloc(sizeof(*new), GFP_KERNEL);
0047 
0048             if (!new)
0049                 return -ENOMEM;
0050 
0051             new->current_index = i;
0052             new->sensor_idx = cli_data->sensor_idx[i];
0053             new->hid = hid;
0054             new->report_type = report_type;
0055             new->report_id = report_id;
0056             cli_data->report_id[i] = report_id;
0057             cli_data->request_done[i] = false;
0058             list_add(&new->list, &req_list->list);
0059             break;
0060         }
0061     }
0062     schedule_delayed_work(&cli_data->work, 0);
0063     return 0;
0064 }
0065 
0066 void amd_sfh_work(struct work_struct *work)
0067 {
0068     struct amdtp_cl_data *cli_data = container_of(work, struct amdtp_cl_data, work.work);
0069     struct request_list *req_list = &cli_data->req_list;
0070     struct amd_input_data *in_data = cli_data->in_data;
0071     struct request_list *req_node;
0072     u8 current_index, sensor_index;
0073     struct amd_mp2_ops *mp2_ops;
0074     struct amd_mp2_dev *mp2;
0075     u8 report_id, node_type;
0076     u8 report_size = 0;
0077 
0078     req_node = list_last_entry(&req_list->list, struct request_list, list);
0079     list_del(&req_node->list);
0080     current_index = req_node->current_index;
0081     sensor_index = req_node->sensor_idx;
0082     report_id = req_node->report_id;
0083     node_type = req_node->report_type;
0084     kfree(req_node);
0085 
0086     mp2 = container_of(in_data, struct amd_mp2_dev, in_data);
0087     mp2_ops = mp2->mp2_ops;
0088     if (node_type == HID_FEATURE_REPORT) {
0089         report_size = mp2_ops->get_feat_rep(sensor_index, report_id,
0090                             cli_data->feature_report[current_index]);
0091         if (report_size)
0092             hid_input_report(cli_data->hid_sensor_hubs[current_index],
0093                      cli_data->report_type[current_index],
0094                      cli_data->feature_report[current_index], report_size, 0);
0095         else
0096             pr_err("AMDSFH: Invalid report size\n");
0097 
0098     } else if (node_type == HID_INPUT_REPORT) {
0099         report_size = mp2_ops->get_in_rep(current_index, sensor_index, report_id, in_data);
0100         if (report_size)
0101             hid_input_report(cli_data->hid_sensor_hubs[current_index],
0102                      cli_data->report_type[current_index],
0103                      in_data->input_report[current_index], report_size, 0);
0104         else
0105             pr_err("AMDSFH: Invalid report size\n");
0106     }
0107     cli_data->cur_hid_dev = current_index;
0108     cli_data->sensor_requested_cnt[current_index] = 0;
0109     amdtp_hid_wakeup(cli_data->hid_sensor_hubs[current_index]);
0110 }
0111 
0112 void amd_sfh_work_buffer(struct work_struct *work)
0113 {
0114     struct amdtp_cl_data *cli_data = container_of(work, struct amdtp_cl_data, work_buffer.work);
0115     struct amd_input_data *in_data = cli_data->in_data;
0116     struct amd_mp2_dev *mp2;
0117     u8 report_size;
0118     int i;
0119 
0120     for (i = 0; i < cli_data->num_hid_devices; i++) {
0121         if (cli_data->sensor_sts[i] == SENSOR_ENABLED) {
0122             mp2 = container_of(in_data, struct amd_mp2_dev, in_data);
0123             report_size = mp2->mp2_ops->get_in_rep(i, cli_data->sensor_idx[i],
0124                                    cli_data->report_id[i], in_data);
0125             hid_input_report(cli_data->hid_sensor_hubs[i], HID_INPUT_REPORT,
0126                      in_data->input_report[i], report_size, 0);
0127         }
0128     }
0129     schedule_delayed_work(&cli_data->work_buffer, msecs_to_jiffies(AMD_SFH_IDLE_LOOP));
0130 }
0131 
0132 static u32 amd_sfh_wait_for_response(struct amd_mp2_dev *mp2, u8 sid, u32 sensor_sts)
0133 {
0134     if (mp2->mp2_ops->response)
0135         sensor_sts = mp2->mp2_ops->response(mp2, sid, sensor_sts);
0136 
0137     return sensor_sts;
0138 }
0139 
0140 static const char *get_sensor_name(int idx)
0141 {
0142     switch (idx) {
0143     case accel_idx:
0144         return "accelerometer";
0145     case gyro_idx:
0146         return "gyroscope";
0147     case mag_idx:
0148         return "magnetometer";
0149     case als_idx:
0150         return "ALS";
0151     case HPD_IDX:
0152         return "HPD";
0153     default:
0154         return "unknown sensor type";
0155     }
0156 }
0157 
0158 static void amd_sfh_resume(struct amd_mp2_dev *mp2)
0159 {
0160     struct amdtp_cl_data *cl_data = mp2->cl_data;
0161     struct amd_mp2_sensor_info info;
0162     int i, status;
0163 
0164     for (i = 0; i < cl_data->num_hid_devices; i++) {
0165         if (cl_data->sensor_sts[i] == SENSOR_DISABLED) {
0166             info.period = AMD_SFH_IDLE_LOOP;
0167             info.sensor_idx = cl_data->sensor_idx[i];
0168             info.dma_address = cl_data->sensor_dma_addr[i];
0169             mp2->mp2_ops->start(mp2, info);
0170             status = amd_sfh_wait_for_response
0171                     (mp2, cl_data->sensor_idx[i], SENSOR_ENABLED);
0172             if (status == SENSOR_ENABLED)
0173                 cl_data->sensor_sts[i] = SENSOR_ENABLED;
0174             dev_dbg(&mp2->pdev->dev, "resume sid 0x%x (%s) status 0x%x\n",
0175                 cl_data->sensor_idx[i], get_sensor_name(cl_data->sensor_idx[i]),
0176                 cl_data->sensor_sts[i]);
0177         }
0178     }
0179 
0180     schedule_delayed_work(&cl_data->work_buffer, msecs_to_jiffies(AMD_SFH_IDLE_LOOP));
0181     amd_sfh_clear_intr(mp2);
0182 }
0183 
0184 static void amd_sfh_suspend(struct amd_mp2_dev *mp2)
0185 {
0186     struct amdtp_cl_data *cl_data = mp2->cl_data;
0187     int i, status;
0188 
0189     for (i = 0; i < cl_data->num_hid_devices; i++) {
0190         if (cl_data->sensor_idx[i] != HPD_IDX &&
0191             cl_data->sensor_sts[i] == SENSOR_ENABLED) {
0192             mp2->mp2_ops->stop(mp2, cl_data->sensor_idx[i]);
0193             status = amd_sfh_wait_for_response
0194                     (mp2, cl_data->sensor_idx[i], SENSOR_DISABLED);
0195             if (status != SENSOR_ENABLED)
0196                 cl_data->sensor_sts[i] = SENSOR_DISABLED;
0197             dev_dbg(&mp2->pdev->dev, "suspend sid 0x%x (%s) status 0x%x\n",
0198                 cl_data->sensor_idx[i], get_sensor_name(cl_data->sensor_idx[i]),
0199                 cl_data->sensor_sts[i]);
0200         }
0201     }
0202 
0203     cancel_delayed_work_sync(&cl_data->work_buffer);
0204     amd_sfh_clear_intr(mp2);
0205 }
0206 
0207 int amd_sfh_hid_client_init(struct amd_mp2_dev *privdata)
0208 {
0209     struct amd_input_data *in_data = &privdata->in_data;
0210     struct amdtp_cl_data *cl_data = privdata->cl_data;
0211     struct amd_mp2_ops *mp2_ops = privdata->mp2_ops;
0212     struct amd_mp2_sensor_info info;
0213     struct request_list *req_list;
0214     struct device *dev;
0215     u32 feature_report_size;
0216     u32 input_report_size;
0217     int rc, i, status;
0218     u8 cl_idx;
0219 
0220     req_list = &cl_data->req_list;
0221     dev = &privdata->pdev->dev;
0222     amd_sfh_set_desc_ops(mp2_ops);
0223 
0224     mp2_ops->suspend = amd_sfh_suspend;
0225     mp2_ops->resume = amd_sfh_resume;
0226 
0227     cl_data->num_hid_devices = amd_mp2_get_sensor_num(privdata, &cl_data->sensor_idx[0]);
0228     if (cl_data->num_hid_devices == 0)
0229         return -ENODEV;
0230 
0231     INIT_DELAYED_WORK(&cl_data->work, amd_sfh_work);
0232     INIT_DELAYED_WORK(&cl_data->work_buffer, amd_sfh_work_buffer);
0233     INIT_LIST_HEAD(&req_list->list);
0234     cl_data->in_data = in_data;
0235 
0236     for (i = 0; i < cl_data->num_hid_devices; i++) {
0237         in_data->sensor_virt_addr[i] = dma_alloc_coherent(dev, sizeof(int) * 8,
0238                                   &cl_data->sensor_dma_addr[i],
0239                                   GFP_KERNEL);
0240         cl_data->sensor_sts[i] = SENSOR_DISABLED;
0241         cl_data->sensor_requested_cnt[i] = 0;
0242         cl_data->cur_hid_dev = i;
0243         cl_idx = cl_data->sensor_idx[i];
0244         cl_data->report_descr_sz[i] = mp2_ops->get_desc_sz(cl_idx, descr_size);
0245         if (!cl_data->report_descr_sz[i]) {
0246             rc = -EINVAL;
0247             goto cleanup;
0248         }
0249         feature_report_size = mp2_ops->get_desc_sz(cl_idx, feature_size);
0250         if (!feature_report_size) {
0251             rc = -EINVAL;
0252             goto cleanup;
0253         }
0254         input_report_size =  mp2_ops->get_desc_sz(cl_idx, input_size);
0255         if (!input_report_size) {
0256             rc = -EINVAL;
0257             goto cleanup;
0258         }
0259         cl_data->feature_report[i] = devm_kzalloc(dev, feature_report_size, GFP_KERNEL);
0260         if (!cl_data->feature_report[i]) {
0261             rc = -ENOMEM;
0262             goto cleanup;
0263         }
0264         in_data->input_report[i] = devm_kzalloc(dev, input_report_size, GFP_KERNEL);
0265         if (!in_data->input_report[i]) {
0266             rc = -ENOMEM;
0267             goto cleanup;
0268         }
0269         info.period = AMD_SFH_IDLE_LOOP;
0270         info.sensor_idx = cl_idx;
0271         info.dma_address = cl_data->sensor_dma_addr[i];
0272 
0273         cl_data->report_descr[i] =
0274             devm_kzalloc(dev, cl_data->report_descr_sz[i], GFP_KERNEL);
0275         if (!cl_data->report_descr[i]) {
0276             rc = -ENOMEM;
0277             goto cleanup;
0278         }
0279         rc = mp2_ops->get_rep_desc(cl_idx, cl_data->report_descr[i]);
0280         if (rc)
0281             return rc;
0282         mp2_ops->start(privdata, info);
0283         status = amd_sfh_wait_for_response
0284                 (privdata, cl_data->sensor_idx[i], SENSOR_ENABLED);
0285         if (status == SENSOR_ENABLED) {
0286             cl_data->sensor_sts[i] = SENSOR_ENABLED;
0287             rc = amdtp_hid_probe(cl_data->cur_hid_dev, cl_data);
0288             if (rc) {
0289                 mp2_ops->stop(privdata, cl_data->sensor_idx[i]);
0290                 status = amd_sfh_wait_for_response
0291                     (privdata, cl_data->sensor_idx[i], SENSOR_DISABLED);
0292                 if (status != SENSOR_ENABLED)
0293                     cl_data->sensor_sts[i] = SENSOR_DISABLED;
0294                 dev_dbg(dev, "sid 0x%x (%s) status 0x%x\n",
0295                     cl_data->sensor_idx[i],
0296                     get_sensor_name(cl_data->sensor_idx[i]),
0297                     cl_data->sensor_sts[i]);
0298                 goto cleanup;
0299             }
0300         }
0301         dev_dbg(dev, "sid 0x%x (%s) status 0x%x\n",
0302             cl_data->sensor_idx[i], get_sensor_name(cl_data->sensor_idx[i]),
0303             cl_data->sensor_sts[i]);
0304     }
0305     if (mp2_ops->discovery_status && mp2_ops->discovery_status(privdata) == 0) {
0306         amd_sfh_hid_client_deinit(privdata);
0307         for (i = 0; i < cl_data->num_hid_devices; i++) {
0308             devm_kfree(dev, cl_data->feature_report[i]);
0309             devm_kfree(dev, in_data->input_report[i]);
0310             devm_kfree(dev, cl_data->report_descr[i]);
0311         }
0312         dev_warn(dev, "Failed to discover, sensors not enabled\n");
0313         return -EOPNOTSUPP;
0314     }
0315     schedule_delayed_work(&cl_data->work_buffer, msecs_to_jiffies(AMD_SFH_IDLE_LOOP));
0316     return 0;
0317 
0318 cleanup:
0319     for (i = 0; i < cl_data->num_hid_devices; i++) {
0320         if (in_data->sensor_virt_addr[i]) {
0321             dma_free_coherent(&privdata->pdev->dev, 8 * sizeof(int),
0322                       in_data->sensor_virt_addr[i],
0323                       cl_data->sensor_dma_addr[i]);
0324         }
0325         devm_kfree(dev, cl_data->feature_report[i]);
0326         devm_kfree(dev, in_data->input_report[i]);
0327         devm_kfree(dev, cl_data->report_descr[i]);
0328     }
0329     return rc;
0330 }
0331 
0332 int amd_sfh_hid_client_deinit(struct amd_mp2_dev *privdata)
0333 {
0334     struct amdtp_cl_data *cl_data = privdata->cl_data;
0335     struct amd_input_data *in_data = cl_data->in_data;
0336     int i, status;
0337 
0338     for (i = 0; i < cl_data->num_hid_devices; i++) {
0339         if (cl_data->sensor_sts[i] == SENSOR_ENABLED) {
0340             privdata->mp2_ops->stop(privdata, cl_data->sensor_idx[i]);
0341             status = amd_sfh_wait_for_response
0342                     (privdata, cl_data->sensor_idx[i], SENSOR_DISABLED);
0343             if (status != SENSOR_ENABLED)
0344                 cl_data->sensor_sts[i] = SENSOR_DISABLED;
0345             dev_dbg(&privdata->pdev->dev, "stopping sid 0x%x (%s) status 0x%x\n",
0346                 cl_data->sensor_idx[i], get_sensor_name(cl_data->sensor_idx[i]),
0347                 cl_data->sensor_sts[i]);
0348         }
0349     }
0350 
0351     cancel_delayed_work_sync(&cl_data->work);
0352     cancel_delayed_work_sync(&cl_data->work_buffer);
0353     amdtp_hid_remove(cl_data);
0354 
0355     for (i = 0; i < cl_data->num_hid_devices; i++) {
0356         if (in_data->sensor_virt_addr[i]) {
0357             dma_free_coherent(&privdata->pdev->dev, 8 * sizeof(int),
0358                       in_data->sensor_virt_addr[i],
0359                       cl_data->sensor_dma_addr[i]);
0360         }
0361     }
0362     return 0;
0363 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!