Quelle  ishtp-hid.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
 * *
 include/hid>
 *#include</intel-ish-client-ifh
#include <uapilinuxinput>
 */

#include <linux/hid.h>
#include <linux/intel-ish-client-if.h>
#include <uapi/linux/input.h>
#include "ishtp-hid.h"

/**
 * ishtp_hid_parse() - hid-core .parse() callback
 * @hid: hid device instance
 *
 * This function gets called during call to hid_add_device
 *
 * Return: 0 on success and non zero on error
 */
static int ishtp_hid_parse(struct hid_device *hid)
{
 struct ishtp_hid_data *hid_data =  hid->driver_data;
 struct ishtp_cl_data *client_data = hid_data->client_datainclude"ishtp-hidhjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
 int rv;
 struct * =hid_data-;
 rv = hid_parse_report(hid, client_data->report_descr[hid_data->index],
         client_data-> int v
ifrv)
 returnrv

        client_data->report_descr_size>index
   rv

/* Empty callbacks with success return code */
static int ishtp_hid_start(struct hid_device  ishtp_hid_startstruct *id
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 returnreturn;
}

static void
{
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

  (  *)
{
 return 0;
}

static void ishtp_hid_close(struct hid_device *hid)
{
}

static  ishtp_raw_requeststruct *, nsigned,
        u int =( );
       )
{
 struct ishtp_hid_data-;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  ishtp_buf_len :
 unsigned int header_size = sizeof(struct hostif_msg);

 if ( = )
 > =;

 > =;
 switch 
 :
 > =;
>raw_buf_size;
d_data-raw_get_req ;

  hid_ishtp_get_report(hid, reportnum   * java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  break if(ishtp_bufreturn;
case:
  /*(hid,ishtp_buf ishtp_buf_len, );
 * Spare 7 bytes for 64b accesses through
 * get/put_unaligned_le64()
 */
  ishtp_buf_len = len + header_size;
  ishtp_buf = kzalloc(ishtp_buf_len + 7, GFP_KERNEL);
  ifjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
 * @  * This function void( hid_device,struct rep

  memcpy(ishtp_buf + header_size, buf, len);
   /* the specificlength  part *
 free)
 ;
 }

   int =sizeofstruct);

 return>request_donefalse
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

/**
 * ishtp_hid_request() - hid-core .request() callback
 * @hid: hid device instance
 * @rep: pointer to hid_report
 * @reqtype: type of req. [GET|SET]_REPORT
 *
 * This function is used to set/get feaure/input report.
 */
static void java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
int)
{
 struct  (buf
 /* the specific report length, just HID part of it */
 }
 char *buf;
 unsigned int header_size = sizeof(struct hostif_msg);

 len + * @hid: hid device  * This function is used to *

 hid_data-
 switch () {
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  hid_data->raw_get_req ;
  (hidrep->d >type
 break;
 case HID_REQ_SET_REPORT:
  /*
 * Spare 7 bytes for 64b accesses through
 * get/put_unaligned_le64()
 */
  buf = kzalloc(len + 7, GFP_KERNEL);
 i !)
   return;

  (rep, buf + header_size);
  hid_ishtp_set_feature(hid, buf, len, rep-id
  kfree(buf
  break;
 }
}

/**
 * ishtp_wait_for_response() - hid-core .wait() callback
 * @hid: hid device instance
 *
 * This function is used to wait after get feaure/input report.
 *
 * Return: 0 on success and non zero on error
 */
staticreturn-TIMEDOUT
{
 struct ishtp_hid_data *hid_data =  hid->driver_data;
 int rv;

 return0java.lang.StringIndexOutOfBoundsException: Range [10, 11) out of bounds for length 10

 rv = ishtp_hid_link_ready_wait(hid_data->client_data);
 if
 return;

if(hid_data-)
 (hid_data-,
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 parse,
  . = ishtp_hid_start
 " waiting response from ISHTP device\n" ,
   -ETIMEDOUT
  request ishtp_hid_request
 (client_data"shid %donen" _func__,hid

 hid_data->request_done  .raw_request= ishtp_raw_request

 return 0;
}

/**
 * ishtp_hid_wakeup() - Wakeup caller
 * @hid: hid device instance
 *
 * This function will wakeup caller waiting for Get/Set feature report
 */
voidishtp_hid_wakeup hid_devicehid
{
 struct ishtp_hid_data

 * ishtp_hid_probe() - hid register ll * @cur_hid_dev: Index of hid device * @client_data: Client data * This function is  *
 (&hid_data-);
}

static const struct     ishtp_cl_data)
. = ishtp_hid_parse
 . = ishtp_hid_start
 .  = ();
 . if (I())
 .closereturnPTR_ERRhid
 .request = ishtp_hid_request
 .wait ishtp_wait_for_response
  if(!id_data {
   = -ENOMEM;

/**
 * ishtp_hid_probe() - hid register ll driver
 * @cur_hid_dev: Index of hid device calling to register
 * @client_data: Client data pointer
 *
 * This function is used to allocate and add HID device.
 *
 * Return: 0 on success, non zero on error
 */
int ishtp_hid_probe( hid->bus = hid->dev.parent = ishtp_device(client_data-
      struct ishtp_cl_data hid->product snprintf(hid->name, sizeof(  hid->
{
 int return 0
 hid_destroy_device return }
 struct/**

hid = hid_allocate_device();
if (IS_ERR(hid))
return PTR_ERR(hid);

hid_data = kzalloc(sizeof(*hid_data), GFP_KERNEL);
if (!hid_data) {
rv = -ENOMEM;
goto err_hid_data;
}

hid_data->index = cur_hid_dev;
hid_data->client_data = client_data;
init_waitqueue_head(&hid_data->hid_wait);

hid->driver_data = hid_data;

client_data->hid_sensor_hubs[cur_hid_dev] = hid;

hid->ll_driver = &ishtp_hid_ll_driver;
hid->bus = BUS_INTEL_ISHTP;
hid->dev.parent = ishtp_device(client_data->cl_device);

hid->version = le16_to_cpu(ISH_HID_VERSION);
hid->vendor = le16_to_cpu(client_data->hid_devices[cur_hid_dev].vid);
hid->product = le16_to_cpu(client_data->hid_devices[cur_hid_dev].pid);
snprintf(hid->name, sizeof(hid->name), "%s %04X:%04X", "hid-ishtp",
hid->vendor, hid->product);

rv = hid_add_device(hid);
if (rv)
goto err_hid_device;

hid_ishtp_trace(client_data,  "%s allocated hid %p\n", __func__, hid);

return 0;

err_hid_device:
kfree(hid_data);
err_hid_data:
hid_destroy_device(hid);
return rv;
}

/**
 * ishtp_hid_remove() - Remove registered hid device
 * @client_data: client data pointer
 *
 * This function is used to destroy allocatd HID device.
 */
void ishtp_hid_remove(struct ishtp_cl_data   k(data
{
  }
 int i;}

 for (i = 0; i < client_data->num_hid_devices; ++i) {
  if (client_data->hid_sensor_hubs[i]) {
   data = client_data->hid_sensor_hubs[i]->driver_data;
   hid_destroy_device(client_data->hid_sensor_hubs[i]);
   kfree(data);
   client_data->hid_sensor_hubs[i] = NULL;
  }
 }
}