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

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