drivers/hid/intel-ish-hid/ishtp-hid-client.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * ISHTP client driver for HID (ISH)
   4  *
   5  * Copyright (c) 2014-2016, Intel Corporation.
   6  */
   7
   8 #include <linux/module.h>
   9 #include <linux/hid.h>
  10 #include <linux/intel-ish-client-if.h>
  11 #include <linux/sched.h>
  12 #include "ishtp-hid.h"
  13
  14 /* ISH Transport protocol (ISHTP in short) GUID */
  15 static const struct ishtp_device_id hid_ishtp_id_table[] = {
  16         { .guid = GUID_INIT(0x33AECD58, 0xB679, 0x4E54,
  17                   0x9B, 0xD9, 0xA0, 0x4D, 0x34, 0xF0, 0xC2, 0x26), },
  18         { }
  19 };
  20 MODULE_DEVICE_TABLE(ishtp, hid_ishtp_id_table);
  21
  22 /* Rx ring buffer pool size */
  23 #define HID_CL_RX_RING_SIZE     32
  24 #define HID_CL_TX_RING_SIZE     16
  25
  26 #define cl_data_to_dev(client_data) ishtp_device(client_data->cl_device)
  27
  28 /**
  29  * report_bad_packet() - Report bad packets
  30  * @hid_ishtp_cl:       Client instance to get stats
  31  * @recv_buf:           Raw received host interface message
  32  * @cur_pos:            Current position index in payload
  33  * @payload_len:        Length of payload expected
  34  *
  35  * Dumps error in case bad packet is received
  36  */
  37 static void report_bad_packet(struct ishtp_cl *hid_ishtp_cl, void *recv_buf,
  38                               size_t cur_pos,  size_t payload_len)
  39 {
  40         struct hostif_msg *recv_msg = recv_buf;
  41         struct ishtp_cl_data *client_data = ishtp_get_client_data(hid_ishtp_cl);
  42
  43         dev_err(cl_data_to_dev(client_data), "[hid-ish]: BAD packet %02X\n"
  44                 "total_bad=%u cur_pos=%u\n"
  45                 "[%02X %02X %02X %02X]\n"
  46                 "payload_len=%u\n"
  47                 "multi_packet_cnt=%u\n"
  48                 "is_response=%02X\n",
  49                 recv_msg->hdr.command, client_data->bad_recv_cnt,
  50                 (unsigned int)cur_pos,
  51                 ((unsigned char *)recv_msg)[0], ((unsigned char *)recv_msg)[1],
  52                 ((unsigned char *)recv_msg)[2], ((unsigned char *)recv_msg)[3],
  53                 (unsigned int)payload_len, client_data->multi_packet_cnt,
  54                 recv_msg->hdr.command & ~CMD_MASK);
  55 }
  56
  57 /**
  58  * process_recv() - Received and parse incoming packet
  59  * @hid_ishtp_cl:       Client instance to get stats
  60  * @recv_buf:           Raw received host interface message
  61  * @data_len:           length of the message
  62  *
  63  * Parse the incoming packet. If it is a response packet then it will update
  64  * per instance flags and wake up the caller waiting to for the response.
  65  */
  66 static void process_recv(struct ishtp_cl *hid_ishtp_cl, void *recv_buf,
  67                          size_t data_len)
  68 {
  69         struct hostif_msg *recv_msg;
  70         unsigned char *payload;
  71         struct device_info *dev_info;
  72         int i, j;
  73         size_t  payload_len, total_len, cur_pos, raw_len;
  74         int report_type;
  75         struct report_list *reports_list;
  76         char *reports;
  77         size_t report_len;
  78         struct ishtp_cl_data *client_data = ishtp_get_client_data(hid_ishtp_cl);
  79         int curr_hid_dev = client_data->cur_hid_dev;
  80         struct ishtp_hid_data *hid_data = NULL;
  81         struct hid_device *hid = NULL;
  82
  83         payload = recv_buf + sizeof(struct hostif_msg_hdr);
  84         total_len = data_len;
  85         cur_pos = 0;
  86
  87         do {
  88                 if (cur_pos + sizeof(struct hostif_msg) > total_len) {
  89                         dev_err(cl_data_to_dev(client_data),
  90                                 "[hid-ish]: error, received %u which is less than data header %u\n",
  91                                 (unsigned int)data_len,
  92                                 (unsigned int)sizeof(struct hostif_msg_hdr));
  93                         ++client_data->bad_recv_cnt;
  94                         ish_hw_reset(ishtp_get_ishtp_device(hid_ishtp_cl));
  95                         break;
  96                 }
  97
  98                 recv_msg = (struct hostif_msg *)(recv_buf + cur_pos);
  99                 payload_len = recv_msg->hdr.size;
 100
 101                 /* Sanity checks */
 102                 if (cur_pos + payload_len + sizeof(struct hostif_msg) >
 103                                 total_len) {
 104                         ++client_data->bad_recv_cnt;
 105                         report_bad_packet(hid_ishtp_cl, recv_msg, cur_pos,
 106                                           payload_len);
 107                         ish_hw_reset(ishtp_get_ishtp_device(hid_ishtp_cl));
 108                         break;
 109                 }
 110
 111                 hid_ishtp_trace(client_data,  "%s %d\n",
 112                                 __func__, recv_msg->hdr.command & CMD_MASK);
 113
 114                 switch (recv_msg->hdr.command & CMD_MASK) {
 115                 case HOSTIF_DM_ENUM_DEVICES:
 116                         if ((!(recv_msg->hdr.command & ~CMD_MASK) ||
 117                                         client_data->init_done)) {
 118                                 ++client_data->bad_recv_cnt;
 119                                 report_bad_packet(hid_ishtp_cl, recv_msg,
 120                                                   cur_pos,
 121                                                   payload_len);
 122                                 ish_hw_reset(ishtp_get_ishtp_device(hid_ishtp_cl));
 123                                 break;
 124                         }
 125                         client_data->hid_dev_count = (unsigned int)*payload;
 126                         if (!client_data->hid_devices)
 127                                 client_data->hid_devices = devm_kcalloc(
 128                                                 cl_data_to_dev(client_data),
 129                                                 client_data->hid_dev_count,
 130                                                 sizeof(struct device_info),
 131                                                 GFP_KERNEL);
 132                         if (!client_data->hid_devices) {
 133                                 dev_err(cl_data_to_dev(client_data),
 134                                 "Mem alloc failed for hid device info\n");
 135                                 wake_up_interruptible(&client_data->init_wait);
 136                                 break;
 137                         }
 138                         for (i = 0; i < client_data->hid_dev_count; ++i) {
 139                                 if (1 + sizeof(struct device_info) * i >=
 140                                                 payload_len) {
 141                                         dev_err(cl_data_to_dev(client_data),
 142                                                 "[hid-ish]: [ENUM_DEVICES]: content size %zu is bigger than payload_len %zu\n",
 143                                                 1 + sizeof(struct device_info)
 144                                                 * i, payload_len);
 145                                 }
 146
 147                                 if (1 + sizeof(struct device_info) * i >=
 148                                                 data_len)
 149                                         break;
 150
 151                                 dev_info = (struct device_info *)(payload + 1 +
 152                                         sizeof(struct device_info) * i);
 153                                 if (client_data->hid_devices)
 154                                         memcpy(client_data->hid_devices + i,
 155                                                dev_info,
 156                                                sizeof(struct device_info));
 157                         }
 158
 159                         client_data->enum_devices_done = true;
 160                         wake_up_interruptible(&client_data->init_wait);
 161
 162                         break;
 163
 164                 case HOSTIF_GET_HID_DESCRIPTOR:
 165                         if ((!(recv_msg->hdr.command & ~CMD_MASK) ||
 166                                         client_data->init_done)) {
 167                                 ++client_data->bad_recv_cnt;
 168                                 report_bad_packet(hid_ishtp_cl, recv_msg,
 169                                                   cur_pos,
 170                                                   payload_len);
 171                                 ish_hw_reset(ishtp_get_ishtp_device(hid_ishtp_cl));
 172                                 break;
 173                         }
 174                         if (!client_data->hid_descr[curr_hid_dev])
 175                                 client_data->hid_descr[curr_hid_dev] =
 176                                 devm_kmalloc(cl_data_to_dev(client_data),
 177                                              payload_len, GFP_KERNEL);
 178                         if (client_data->hid_descr[curr_hid_dev]) {
 179                                 memcpy(client_data->hid_descr[curr_hid_dev],
 180                                        payload, payload_len);
 181                                 client_data->hid_descr_size[curr_hid_dev] =
 182                                         payload_len;
 183                                 client_data->hid_descr_done = true;
 184                         }
 185                         wake_up_interruptible(&client_data->init_wait);
 186
 187                         break;
 188
 189                 case HOSTIF_GET_REPORT_DESCRIPTOR:
 190                         if ((!(recv_msg->hdr.command & ~CMD_MASK) ||
 191                                         client_data->init_done)) {
 192                                 ++client_data->bad_recv_cnt;
 193                                 report_bad_packet(hid_ishtp_cl, recv_msg,
 194                                                   cur_pos,
 195                                                   payload_len);
 196                                 ish_hw_reset(ishtp_get_ishtp_device(hid_ishtp_cl));
 197                                 break;
 198                         }
 199                         if (!client_data->report_descr[curr_hid_dev])
 200                                 client_data->report_descr[curr_hid_dev] =
 201                                 devm_kmalloc(cl_data_to_dev(client_data),
 202                                              payload_len, GFP_KERNEL);
 203                         if (client_data->report_descr[curr_hid_dev])  {
 204                                 memcpy(client_data->report_descr[curr_hid_dev],
 205                                        payload,
 206                                        payload_len);
 207                                 client_data->report_descr_size[curr_hid_dev] =
 208                                         payload_len;
 209                                 client_data->report_descr_done = true;
 210                         }
 211                         wake_up_interruptible(&client_data->init_wait);
 212
 213                         break;
 214
 215                 case HOSTIF_GET_FEATURE_REPORT:
 216                         report_type = HID_FEATURE_REPORT;
 217                         goto    do_get_report;
 218
 219                 case HOSTIF_GET_INPUT_REPORT:
 220                         report_type = HID_INPUT_REPORT;
 221 do_get_report:
 222                         /* Get index of device that matches this id */
 223                         for (i = 0; i < client_data->num_hid_devices; ++i) {
 224                                 if (recv_msg->hdr.device_id ==
 225                                           client_data->hid_devices[i].dev_id) {
 226                                         hid = client_data->hid_sensor_hubs[i];
 227                                         if (!hid)
 228                                                 break;
 229
 230                                         hid_data = hid->driver_data;
 231                                         if (hid_data->raw_get_req) {
 232                                                 raw_len =
 233                                                   (hid_data->raw_buf_size <
 234                                                                 payload_len) ?
 235                                                   hid_data->raw_buf_size :
 236                                                   payload_len;
 237
 238                                                 memcpy(hid_data->raw_buf,
 239                                                        payload, raw_len);
 240                                         } else {
 241                                                 hid_input_report
 242                                                         (hid, report_type,
 243                                                          payload, payload_len,
 244                                                          0);
 245                                         }
 246
 247                                         ishtp_hid_wakeup(hid);
 248                                         break;
 249                                 }
 250                         }
 251                         break;
 252
 253                 case HOSTIF_SET_FEATURE_REPORT:
 254                         /* Get index of device that matches this id */
 255                         for (i = 0; i < client_data->num_hid_devices; ++i) {
 256                                 if (recv_msg->hdr.device_id ==
 257                                         client_data->hid_devices[i].dev_id)
 258                                         if (client_data->hid_sensor_hubs[i]) {
 259                                                 ishtp_hid_wakeup(
 260                                                 client_data->hid_sensor_hubs[
 261                                                         i]);
 262                                                 break;
 263                                         }
 264                         }
 265                         break;
 266
 267                 case HOSTIF_PUBLISH_INPUT_REPORT:
 268                         report_type = HID_INPUT_REPORT;
 269                         for (i = 0; i < client_data->num_hid_devices; ++i)
 270                                 if (recv_msg->hdr.device_id ==
 271                                         client_data->hid_devices[i].dev_id)
 272                                         if (client_data->hid_sensor_hubs[i])
 273                                                 hid_input_report(
 274                                                 client_data->hid_sensor_hubs[
 275                                                                         i],
 276                                                 report_type, payload,
 277                                                 payload_len, 0);
 278                         break;
 279
 280                 case HOSTIF_PUBLISH_INPUT_REPORT_LIST:
 281                         report_type = HID_INPUT_REPORT;
 282                         reports_list = (struct report_list *)payload;
 283                         reports = (char *)reports_list->reports;
 284
 285                         for (j = 0; j < reports_list->num_of_reports; j++) {
 286                                 recv_msg = (struct hostif_msg *)(reports +
 287                                         sizeof(uint16_t));
 288                                 report_len = *(uint16_t *)reports;
 289                                 payload = reports + sizeof(uint16_t) +
 290                                         sizeof(struct hostif_msg_hdr);
 291                                 payload_len = report_len -
 292                                         sizeof(struct hostif_msg_hdr);
 293
 294                                 for (i = 0; i < client_data->num_hid_devices;
 295                                      ++i)
 296                                         if (recv_msg->hdr.device_id ==
 297                                         client_data->hid_devices[i].dev_id &&
 298                                         client_data->hid_sensor_hubs[i]) {
 299                                                 hid_input_report(
 300                                                 client_data->hid_sensor_hubs[
 301                                                                         i],
 302                                                 report_type,
 303                                                 payload, payload_len,
 304                                                 0);
 305                                         }
 306
 307                                 reports += sizeof(uint16_t) + report_len;
 308                         }
 309                         break;
 310                 default:
 311                         ++client_data->bad_recv_cnt;
 312                         report_bad_packet(hid_ishtp_cl, recv_msg, cur_pos,
 313                                           payload_len);
 314                         ish_hw_reset(ishtp_get_ishtp_device(hid_ishtp_cl));
 315                         break;
 316
 317                 }
 318
 319                 if (!cur_pos && cur_pos + payload_len +
 320                                 sizeof(struct hostif_msg) < total_len)
 321                         ++client_data->multi_packet_cnt;
 322
 323                 cur_pos += payload_len + sizeof(struct hostif_msg);
 324                 payload += payload_len + sizeof(struct hostif_msg);
 325
 326         } while (cur_pos < total_len);
 327 }
 328
 329 /**
 330  * ish_cl_event_cb() - bus driver callback for incoming message/packet
 331  * @device:     Pointer to the the ishtp client device for which this message
 332  *              is targeted
 333  *
 334  * Remove the packet from the list and process the message by calling
 335  * process_recv
 336  */
 337 static void ish_cl_event_cb(struct ishtp_cl_device *device)
 338 {
 339         struct ishtp_cl *hid_ishtp_cl = ishtp_get_drvdata(device);
 340         struct ishtp_cl_rb *rb_in_proc;
 341         size_t r_length;
 342
 343         if (!hid_ishtp_cl)
 344                 return;
 345
 346         while ((rb_in_proc = ishtp_cl_rx_get_rb(hid_ishtp_cl)) != NULL) {
 347                 if (!rb_in_proc->buffer.data)
 348                         return;
 349
 350                 r_length = rb_in_proc->buf_idx;
 351
 352                 /* decide what to do with received data */
 353                 process_recv(hid_ishtp_cl, rb_in_proc->buffer.data, r_length);
 354
 355                 ishtp_cl_io_rb_recycle(rb_in_proc);
 356         }
 357 }
 358
 359 /**
 360  * hid_ishtp_set_feature() - send request to ISH FW to set a feature request
 361  * @hid:        hid device instance for this request
 362  * @buf:        feature buffer
 363  * @len:        Length of feature buffer
 364  * @report_id:  Report id for the feature set request
 365  *
 366  * This is called from hid core .request() callback. This function doesn't wait
 367  * for response.
 368  */
 369 void hid_ishtp_set_feature(struct hid_device *hid, char *buf, unsigned int len,
 370                            int report_id)
 371 {
 372         struct ishtp_hid_data *hid_data =  hid->driver_data;
 373         struct ishtp_cl_data *client_data = hid_data->client_data;
 374         struct hostif_msg *msg = (struct hostif_msg *)buf;
 375         int     rv;
 376         int     i;
 377
 378         hid_ishtp_trace(client_data,  "%s hid %p\n", __func__, hid);
 379
 380         rv = ishtp_hid_link_ready_wait(client_data);
 381         if (rv) {
 382                 hid_ishtp_trace(client_data,  "%s hid %p link not ready\n",
 383                                 __func__, hid);
 384                 return;
 385         }
 386
 387         memset(msg, 0, sizeof(struct hostif_msg));
 388         msg->hdr.command = HOSTIF_SET_FEATURE_REPORT;
 389         for (i = 0; i < client_data->num_hid_devices; ++i) {
 390                 if (hid == client_data->hid_sensor_hubs[i]) {
 391                         msg->hdr.device_id =
 392                                 client_data->hid_devices[i].dev_id;
 393                         break;
 394                 }
 395         }
 396
 397         if (i == client_data->num_hid_devices)
 398                 return;
 399
 400         rv = ishtp_cl_send(client_data->hid_ishtp_cl, buf, len);
 401         if (rv)
 402                 hid_ishtp_trace(client_data,  "%s hid %p send failed\n",
 403                                 __func__, hid);
 404 }
 405
 406 /**
 407  * hid_ishtp_get_report() - request to get feature/input report
 408  * @hid:        hid device instance for this request
 409  * @report_id:  Report id for the get request
 410  * @report_type:        Report type for the this request
 411  *
 412  * This is called from hid core .request() callback. This function will send
 413  * request to FW and return without waiting for response.
 414  */
 415 void hid_ishtp_get_report(struct hid_device *hid, int report_id,
 416                           int report_type)
 417 {
 418         struct ishtp_hid_data *hid_data =  hid->driver_data;
 419         struct ishtp_cl_data *client_data = hid_data->client_data;
 420         struct hostif_msg_to_sensor msg = {};
 421         int     rv;
 422         int     i;
 423
 424         hid_ishtp_trace(client_data,  "%s hid %p\n", __func__, hid);
 425         rv = ishtp_hid_link_ready_wait(client_data);
 426         if (rv) {
 427                 hid_ishtp_trace(client_data,  "%s hid %p link not ready\n",
 428                                 __func__, hid);
 429                 return;
 430         }
 431
 432         msg.hdr.command = (report_type == HID_FEATURE_REPORT) ?
 433                 HOSTIF_GET_FEATURE_REPORT : HOSTIF_GET_INPUT_REPORT;
 434         for (i = 0; i < client_data->num_hid_devices; ++i) {
 435                 if (hid == client_data->hid_sensor_hubs[i]) {
 436                         msg.hdr.device_id =
 437                                 client_data->hid_devices[i].dev_id;
 438                         break;
 439                 }
 440         }
 441
 442         if (i == client_data->num_hid_devices)
 443                 return;
 444
 445         msg.report_id = report_id;
 446         rv = ishtp_cl_send(client_data->hid_ishtp_cl, (uint8_t *)&msg,
 447                             sizeof(msg));
 448         if (rv)
 449                 hid_ishtp_trace(client_data,  "%s hid %p send failed\n",
 450                                 __func__, hid);
 451 }
 452
 453 /**
 454  * ishtp_hid_link_ready_wait() - Wait for link ready
 455  * @client_data:        client data instance
 456  *
 457  * If the transport link started suspend process, then wait, till either
 458  * resumed or timeout
 459  *
 460  * Return: 0 on success, non zero on error
 461  */
 462 int ishtp_hid_link_ready_wait(struct ishtp_cl_data *client_data)
 463 {
 464         int rc;
 465
 466         if (client_data->suspended) {
 467                 hid_ishtp_trace(client_data,  "wait for link ready\n");
 468                 rc = wait_event_interruptible_timeout(
 469                                         client_data->ishtp_resume_wait,
 470                                         !client_data->suspended,
 471                                         5 * HZ);
 472
 473                 if (rc == 0) {
 474                         hid_ishtp_trace(client_data,  "link not ready\n");
 475                         return -EIO;
 476                 }
 477                 hid_ishtp_trace(client_data,  "link ready\n");
 478         }
 479
 480         return 0;
 481 }
 482
 483 /**
 484  * ishtp_enum_enum_devices() - Enumerate hid devices
 485  * @hid_ishtp_cl:       client instance
 486  *
 487  * Helper function to send request to firmware to enumerate HID devices
 488  *
 489  * Return: 0 on success, non zero on error
 490  */
 491 static int ishtp_enum_enum_devices(struct ishtp_cl *hid_ishtp_cl)
 492 {
 493         struct hostif_msg msg;
 494         struct ishtp_cl_data *client_data = ishtp_get_client_data(hid_ishtp_cl);
 495         int retry_count;
 496         int rv;
 497
 498         /* Send HOSTIF_DM_ENUM_DEVICES */
 499         memset(&msg, 0, sizeof(struct hostif_msg));
 500         msg.hdr.command = HOSTIF_DM_ENUM_DEVICES;
 501         rv = ishtp_cl_send(hid_ishtp_cl, (unsigned char *)&msg,
 502                            sizeof(struct hostif_msg));
 503         if (rv)
 504                 return rv;
 505
 506         retry_count = 0;
 507         while (!client_data->enum_devices_done &&
 508                retry_count < 10) {
 509                 wait_event_interruptible_timeout(client_data->init_wait,
 510                                          client_data->enum_devices_done,
 511                                          3 * HZ);
 512                 ++retry_count;
 513                 if (!client_data->enum_devices_done)
 514                         /* Send HOSTIF_DM_ENUM_DEVICES */
 515                         rv = ishtp_cl_send(hid_ishtp_cl,
 516                                            (unsigned char *) &msg,
 517                                            sizeof(struct hostif_msg));
 518         }
 519         if (!client_data->enum_devices_done) {
 520                 dev_err(cl_data_to_dev(client_data),
 521                         "[hid-ish]: timed out waiting for enum_devices\n");
 522                 return -ETIMEDOUT;
 523         }
 524         if (!client_data->hid_devices) {
 525                 dev_err(cl_data_to_dev(client_data),
 526                         "[hid-ish]: failed to allocate HID dev structures\n");
 527                 return -ENOMEM;
 528         }
 529
 530         client_data->num_hid_devices = client_data->hid_dev_count;
 531         dev_info(ishtp_device(client_data->cl_device),
 532                 "[hid-ish]: enum_devices_done OK, num_hid_devices=%d\n",
 533                 client_data->num_hid_devices);
 534
 535         return  0;
 536 }
 537
 538 /**
 539  * ishtp_get_hid_descriptor() - Get hid descriptor
 540  * @hid_ishtp_cl:       client instance
 541  * @index:              Index into the hid_descr array
 542  *
 543  * Helper function to send request to firmware get HID descriptor of a device
 544  *
 545  * Return: 0 on success, non zero on error
 546  */
 547 static int ishtp_get_hid_descriptor(struct ishtp_cl *hid_ishtp_cl, int index)
 548 {
 549         struct hostif_msg msg;
 550         struct ishtp_cl_data *client_data = ishtp_get_client_data(hid_ishtp_cl);
 551         int rv;
 552
 553         /* Get HID descriptor */
 554         client_data->hid_descr_done = false;
 555         memset(&msg, 0, sizeof(struct hostif_msg));
 556         msg.hdr.command = HOSTIF_GET_HID_DESCRIPTOR;
 557         msg.hdr.device_id = client_data->hid_devices[index].dev_id;
 558         rv = ishtp_cl_send(hid_ishtp_cl, (unsigned char *) &msg,
 559                            sizeof(struct hostif_msg));
 560         if (rv)
 561                 return rv;
 562
 563         if (!client_data->hid_descr_done) {
 564                 wait_event_interruptible_timeout(client_data->init_wait,
 565                                                  client_data->hid_descr_done,
 566                                                  3 * HZ);
 567                 if (!client_data->hid_descr_done) {
 568                         dev_err(cl_data_to_dev(client_data),
 569                                 "[hid-ish]: timed out for hid_descr_done\n");
 570                         return -EIO;
 571                 }
 572
 573                 if (!client_data->hid_descr[index]) {
 574                         dev_err(cl_data_to_dev(client_data),
 575                                 "[hid-ish]: allocation HID desc fail\n");
 576                         return -ENOMEM;
 577                 }
 578         }
 579
 580         return 0;
 581 }
 582
 583 /**
 584  * ishtp_get_report_descriptor() - Get report descriptor
 585  * @hid_ishtp_cl:       client instance
 586  * @index:              Index into the hid_descr array
 587  *
 588  * Helper function to send request to firmware get HID report descriptor of
 589  * a device
 590  *
 591  * Return: 0 on success, non zero on error
 592  */
 593 static int ishtp_get_report_descriptor(struct ishtp_cl *hid_ishtp_cl,
 594                                        int index)
 595 {
 596         struct hostif_msg msg;
 597         struct ishtp_cl_data *client_data = ishtp_get_client_data(hid_ishtp_cl);
 598         int rv;
 599
 600         /* Get report descriptor */
 601         client_data->report_descr_done = false;
 602         memset(&msg, 0, sizeof(struct hostif_msg));
 603         msg.hdr.command = HOSTIF_GET_REPORT_DESCRIPTOR;
 604         msg.hdr.device_id = client_data->hid_devices[index].dev_id;
 605         rv = ishtp_cl_send(hid_ishtp_cl, (unsigned char *) &msg,
 606                            sizeof(struct hostif_msg));
 607         if (rv)
 608                 return rv;
 609
 610         if (!client_data->report_descr_done)
 611                 wait_event_interruptible_timeout(client_data->init_wait,
 612                                          client_data->report_descr_done,
 613                                          3 * HZ);
 614         if (!client_data->report_descr_done) {
 615                 dev_err(cl_data_to_dev(client_data),
 616                                 "[hid-ish]: timed out for report descr\n");
 617                 return -EIO;
 618         }
 619         if (!client_data->report_descr[index]) {
 620                 dev_err(cl_data_to_dev(client_data),
 621                         "[hid-ish]: failed to alloc report descr\n");
 622                 return -ENOMEM;
 623         }
 624
 625         return 0;
 626 }
 627
 628 /**
 629  * hid_ishtp_cl_init() - Init function for ISHTP client
 630  * @hid_ishtp_cl:       ISHTP client instance
 631  * @reset:              true if called for init after reset
 632  *
 633  * This function complete the initializtion of the client. The summary of
 634  * processing:
 635  * - Send request to enumerate the hid clients
 636  *      Get the HID descriptor for each enumearated device
 637  *      Get report description of each device
 638  *      Register each device wik hid core by calling ishtp_hid_probe
 639  *
 640  * Return: 0 on success, non zero on error
 641  */
 642 static int hid_ishtp_cl_init(struct ishtp_cl *hid_ishtp_cl, int reset)
 643 {
 644         struct ishtp_device *dev;
 645         struct ishtp_cl_data *client_data = ishtp_get_client_data(hid_ishtp_cl);
 646         struct ishtp_fw_client *fw_client;
 647         int i;
 648         int rv;
 649
 650         dev_dbg(cl_data_to_dev(client_data), "%s\n", __func__);
 651         hid_ishtp_trace(client_data,  "%s reset flag: %d\n", __func__, reset);
 652
 653         rv = ishtp_cl_link(hid_ishtp_cl);
 654         if (rv) {
 655                 dev_err(cl_data_to_dev(client_data),
 656                         "ishtp_cl_link failed\n");
 657                 return  -ENOMEM;
 658         }
 659
 660         client_data->init_done = 0;
 661
 662         dev = ishtp_get_ishtp_device(hid_ishtp_cl);
 663
 664         /* Connect to FW client */
 665         ishtp_set_tx_ring_size(hid_ishtp_cl, HID_CL_TX_RING_SIZE);
 666         ishtp_set_rx_ring_size(hid_ishtp_cl, HID_CL_RX_RING_SIZE);
 667
 668         fw_client = ishtp_fw_cl_get_client(dev, &hid_ishtp_id_table[0].guid);
 669         if (!fw_client) {
 670                 dev_err(cl_data_to_dev(client_data),
 671                         "ish client uuid not found\n");
 672                 return -ENOENT;
 673         }
 674         ishtp_cl_set_fw_client_id(hid_ishtp_cl,
 675                                   ishtp_get_fw_client_id(fw_client));
 676         ishtp_set_connection_state(hid_ishtp_cl, ISHTP_CL_CONNECTING);
 677
 678         rv = ishtp_cl_connect(hid_ishtp_cl);
 679         if (rv) {
 680                 dev_err(cl_data_to_dev(client_data),
 681                         "client connect fail\n");
 682                 goto err_cl_unlink;
 683         }
 684
 685         hid_ishtp_trace(client_data,  "%s client connected\n", __func__);
 686
 687         /* Register read callback */
 688         ishtp_register_event_cb(client_data->cl_device, ish_cl_event_cb);
 689
 690         rv = ishtp_enum_enum_devices(hid_ishtp_cl);
 691         if (rv)
 692                 goto err_cl_disconnect;
 693
 694         hid_ishtp_trace(client_data,  "%s enumerated device count %d\n",
 695                         __func__, client_data->num_hid_devices);
 696
 697         for (i = 0; i < client_data->num_hid_devices; ++i) {
 698                 client_data->cur_hid_dev = i;
 699
 700                 rv = ishtp_get_hid_descriptor(hid_ishtp_cl, i);
 701                 if (rv)
 702                         goto err_cl_disconnect;
 703
 704                 rv = ishtp_get_report_descriptor(hid_ishtp_cl, i);
 705                 if (rv)
 706                         goto err_cl_disconnect;
 707
 708                 if (!reset) {
 709                         rv = ishtp_hid_probe(i, client_data);
 710                         if (rv) {
 711                                 dev_err(cl_data_to_dev(client_data),
 712                                 "[hid-ish]: HID probe for #%u failed: %d\n",
 713                                 i, rv);
 714                                 goto err_cl_disconnect;
 715                         }
 716                 }
 717         } /* for() on all hid devices */
 718
 719         client_data->init_done = 1;
 720         client_data->suspended = false;
 721         wake_up_interruptible(&client_data->ishtp_resume_wait);
 722         hid_ishtp_trace(client_data,  "%s successful init\n", __func__);
 723         return 0;
 724
 725 err_cl_disconnect:
 726         ishtp_set_connection_state(hid_ishtp_cl, ISHTP_CL_DISCONNECTING);
 727         ishtp_cl_disconnect(hid_ishtp_cl);
 728 err_cl_unlink:
 729         ishtp_cl_unlink(hid_ishtp_cl);
 730         return rv;
 731 }
 732
 733 /**
 734  * hid_ishtp_cl_deinit() - Deinit function for ISHTP client
 735  * @hid_ishtp_cl:       ISHTP client instance
 736  *
 737  * Unlink and free hid client
 738  */
 739 static void hid_ishtp_cl_deinit(struct ishtp_cl *hid_ishtp_cl)
 740 {
 741         ishtp_cl_unlink(hid_ishtp_cl);
 742         ishtp_cl_flush_queues(hid_ishtp_cl);
 743
 744         /* disband and free all Tx and Rx client-level rings */
 745         ishtp_cl_free(hid_ishtp_cl);
 746 }
 747
 748 static void hid_ishtp_cl_reset_handler(struct work_struct *work)
 749 {
 750         struct ishtp_cl_data *client_data;
 751         struct ishtp_cl *hid_ishtp_cl;
 752         struct ishtp_cl_device *cl_device;
 753         int retry;
 754         int rv;
 755
 756         client_data = container_of(work, struct ishtp_cl_data, work);
 757
 758         hid_ishtp_cl = client_data->hid_ishtp_cl;
 759         cl_device = client_data->cl_device;
 760
 761         hid_ishtp_trace(client_data, "%s hid_ishtp_cl %p\n", __func__,
 762                         hid_ishtp_cl);
 763         dev_dbg(ishtp_device(client_data->cl_device), "%s\n", __func__);
 764
 765         hid_ishtp_cl_deinit(hid_ishtp_cl);
 766
 767         hid_ishtp_cl = ishtp_cl_allocate(cl_device);
 768         if (!hid_ishtp_cl)
 769                 return;
 770
 771         ishtp_set_drvdata(cl_device, hid_ishtp_cl);
 772         ishtp_set_client_data(hid_ishtp_cl, client_data);
 773         client_data->hid_ishtp_cl = hid_ishtp_cl;
 774
 775         client_data->num_hid_devices = 0;
 776
 777         for (retry = 0; retry < 3; ++retry) {
 778                 rv = hid_ishtp_cl_init(hid_ishtp_cl, 1);
 779                 if (!rv)
 780                         break;
 781                 dev_err(cl_data_to_dev(client_data), "Retry reset init\n");
 782         }
 783         if (rv) {
 784                 dev_err(cl_data_to_dev(client_data), "Reset Failed\n");
 785                 hid_ishtp_trace(client_data, "%s Failed hid_ishtp_cl %p\n",
 786                                 __func__, hid_ishtp_cl);
 787         }
 788 }
 789
 790 static void hid_ishtp_cl_resume_handler(struct work_struct *work)
 791 {
 792         struct ishtp_cl_data *client_data = container_of(work, struct ishtp_cl_data, resume_work);
 793         struct ishtp_cl *hid_ishtp_cl = client_data->hid_ishtp_cl;
 794
 795         if (ishtp_wait_resume(ishtp_get_ishtp_device(hid_ishtp_cl))) {
 796                 client_data->suspended = false;
 797                 wake_up_interruptible(&client_data->ishtp_resume_wait);
 798         }
 799 }
 800
 801 ishtp_print_log ishtp_hid_print_trace;
 802
 803 /**
 804  * hid_ishtp_cl_probe() - ISHTP client driver probe
 805  * @cl_device:          ISHTP client device instance
 806  *
 807  * This function gets called on device create on ISHTP bus
 808  *
 809  * Return: 0 on success, non zero on error
 810  */
 811 static int hid_ishtp_cl_probe(struct ishtp_cl_device *cl_device)
 812 {
 813         struct ishtp_cl *hid_ishtp_cl;
 814         struct ishtp_cl_data *client_data;
 815         int rv;
 816
 817         if (!cl_device)
 818                 return  -ENODEV;
 819
 820         client_data = devm_kzalloc(ishtp_device(cl_device),
 821                                    sizeof(*client_data),
 822                                    GFP_KERNEL);
 823         if (!client_data)
 824                 return -ENOMEM;
 825
 826         hid_ishtp_cl = ishtp_cl_allocate(cl_device);
 827         if (!hid_ishtp_cl)
 828                 return -ENOMEM;
 829
 830         ishtp_set_drvdata(cl_device, hid_ishtp_cl);
 831         ishtp_set_client_data(hid_ishtp_cl, client_data);
 832         client_data->hid_ishtp_cl = hid_ishtp_cl;
 833         client_data->cl_device = cl_device;
 834
 835         init_waitqueue_head(&client_data->init_wait);
 836         init_waitqueue_head(&client_data->ishtp_resume_wait);
 837
 838         INIT_WORK(&client_data->work, hid_ishtp_cl_reset_handler);
 839         INIT_WORK(&client_data->resume_work, hid_ishtp_cl_resume_handler);
 840
 841
 842         ishtp_hid_print_trace = ishtp_trace_callback(cl_device);
 843
 844         rv = hid_ishtp_cl_init(hid_ishtp_cl, 0);
 845         if (rv) {
 846                 ishtp_cl_free(hid_ishtp_cl);
 847                 return rv;
 848         }
 849         ishtp_get_device(cl_device);
 850
 851         return 0;
 852 }
 853
 854 /**
 855  * hid_ishtp_cl_remove() - ISHTP client driver remove
 856  * @cl_device:          ISHTP client device instance
 857  *
 858  * This function gets called on device remove on ISHTP bus
 859  *
 860  * Return: 0
 861  */
 862 static void hid_ishtp_cl_remove(struct ishtp_cl_device *cl_device)
 863 {
 864         struct ishtp_cl *hid_ishtp_cl = ishtp_get_drvdata(cl_device);
 865         struct ishtp_cl_data *client_data = ishtp_get_client_data(hid_ishtp_cl);
 866
 867         hid_ishtp_trace(client_data, "%s hid_ishtp_cl %p\n", __func__,
 868                         hid_ishtp_cl);
 869
 870         dev_dbg(ishtp_device(cl_device), "%s\n", __func__);
 871         ishtp_set_connection_state(hid_ishtp_cl, ISHTP_CL_DISCONNECTING);
 872         ishtp_cl_disconnect(hid_ishtp_cl);
 873         ishtp_put_device(cl_device);
 874         ishtp_hid_remove(client_data);
 875         hid_ishtp_cl_deinit(hid_ishtp_cl);
 876
 877         hid_ishtp_cl = NULL;
 878
 879         client_data->num_hid_devices = 0;
 880 }
 881
 882 /**
 883  * hid_ishtp_cl_reset() - ISHTP client driver reset
 884  * @cl_device:          ISHTP client device instance
 885  *
 886  * This function gets called on device reset on ISHTP bus
 887  *
 888  * Return: 0
 889  */
 890 static int hid_ishtp_cl_reset(struct ishtp_cl_device *cl_device)
 891 {
 892         struct ishtp_cl *hid_ishtp_cl = ishtp_get_drvdata(cl_device);
 893         struct ishtp_cl_data *client_data = ishtp_get_client_data(hid_ishtp_cl);
 894
 895         hid_ishtp_trace(client_data, "%s hid_ishtp_cl %p\n", __func__,
 896                         hid_ishtp_cl);
 897
 898         schedule_work(&client_data->work);
 899
 900         return 0;
 901 }
 902
 903 /**
 904  * hid_ishtp_cl_suspend() - ISHTP client driver suspend
 905  * @device:     device instance
 906  *
 907  * This function gets called on system suspend
 908  *
 909  * Return: 0
 910  */
 911 static int hid_ishtp_cl_suspend(struct device *device)
 912 {
 913         struct ishtp_cl_device *cl_device = ishtp_dev_to_cl_device(device);
 914         struct ishtp_cl *hid_ishtp_cl = ishtp_get_drvdata(cl_device);
 915         struct ishtp_cl_data *client_data = ishtp_get_client_data(hid_ishtp_cl);
 916
 917         hid_ishtp_trace(client_data, "%s hid_ishtp_cl %p\n", __func__,
 918                         hid_ishtp_cl);
 919         client_data->suspended = true;
 920
 921         return 0;
 922 }
 923
 924 /**
 925  * hid_ishtp_cl_resume() - ISHTP client driver resume
 926  * @device:     device instance
 927  *
 928  * This function gets called on system resume
 929  *
 930  * Return: 0
 931  */
 932 static int hid_ishtp_cl_resume(struct device *device)
 933 {
 934         struct ishtp_cl_device *cl_device = ishtp_dev_to_cl_device(device);
 935         struct ishtp_cl *hid_ishtp_cl = ishtp_get_drvdata(cl_device);
 936         struct ishtp_cl_data *client_data = ishtp_get_client_data(hid_ishtp_cl);
 937
 938         hid_ishtp_trace(client_data, "%s hid_ishtp_cl %p\n", __func__,
 939                         hid_ishtp_cl);
 940         schedule_work(&client_data->resume_work);
 941         return 0;
 942 }
 943
 944 static const struct dev_pm_ops hid_ishtp_pm_ops = {
 945         .suspend = hid_ishtp_cl_suspend,
 946         .resume = hid_ishtp_cl_resume,
 947 };
 948
 949 static struct ishtp_cl_driver   hid_ishtp_cl_driver = {
 950         .name = "ish-hid",
 951         .id = hid_ishtp_id_table,
 952         .probe = hid_ishtp_cl_probe,
 953         .remove = hid_ishtp_cl_remove,
 954         .reset = hid_ishtp_cl_reset,
 955         .driver.pm = &hid_ishtp_pm_ops,
 956 };
 957
 958 static int __init ish_hid_init(void)
 959 {
 960         int     rv;
 961
 962         /* Register ISHTP client device driver with ISHTP Bus */
 963         rv = ishtp_cl_driver_register(&hid_ishtp_cl_driver, THIS_MODULE);
 964
 965         return rv;
 966
 967 }
 968
 969 static void __exit ish_hid_exit(void)
 970 {
 971         ishtp_cl_driver_unregister(&hid_ishtp_cl_driver);
 972 }
 973
 974 late_initcall(ish_hid_init);
 975 module_exit(ish_hid_exit);
 976
 977 MODULE_DESCRIPTION("ISH ISHTP HID client driver");
 978 /* Primary author */
 979 MODULE_AUTHOR("Daniel Drubin <[email protected]>");
 980 /*
 981  * Several modification for multi instance support
 982  * suspend/resume and clean up
 983  */
 984 MODULE_AUTHOR("Srinivas Pandruvada <[email protected]>");
 985
 986 MODULE_LICENSE("GPL");