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:*"); 978