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