1 /* 2 * 3 * Intel Management Engine Interface (Intel MEI) Linux driver 4 * Copyright (c) 2003-2012, 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 17 #include <linux/export.h> 18 #include <linux/sched.h> 19 #include <linux/wait.h> 20 #include <linux/pm_runtime.h> 21 #include <linux/slab.h> 22 23 #include <linux/mei.h> 24 25 #include "mei_dev.h" 26 #include "hbm.h" 27 #include "client.h" 28 29 static const char *mei_hbm_status_str(enum mei_hbm_status status) 30 { 31 #define MEI_HBM_STATUS(status) case MEI_HBMS_##status: return #status 32 switch (status) { 33 MEI_HBM_STATUS(SUCCESS); 34 MEI_HBM_STATUS(CLIENT_NOT_FOUND); 35 MEI_HBM_STATUS(ALREADY_EXISTS); 36 MEI_HBM_STATUS(REJECTED); 37 MEI_HBM_STATUS(INVALID_PARAMETER); 38 MEI_HBM_STATUS(NOT_ALLOWED); 39 MEI_HBM_STATUS(ALREADY_STARTED); 40 MEI_HBM_STATUS(NOT_STARTED); 41 default: return "unknown"; 42 } 43 #undef MEI_HBM_STATUS 44 }; 45 46 static const char *mei_cl_conn_status_str(enum mei_cl_connect_status status) 47 { 48 #define MEI_CL_CS(status) case MEI_CL_CONN_##status: return #status 49 switch (status) { 50 MEI_CL_CS(SUCCESS); 51 MEI_CL_CS(NOT_FOUND); 52 MEI_CL_CS(ALREADY_STARTED); 53 MEI_CL_CS(OUT_OF_RESOURCES); 54 MEI_CL_CS(MESSAGE_SMALL); 55 MEI_CL_CS(NOT_ALLOWED); 56 default: return "unknown"; 57 } 58 #undef MEI_CL_CCS 59 } 60 61 const char *mei_hbm_state_str(enum mei_hbm_state state) 62 { 63 #define MEI_HBM_STATE(state) case MEI_HBM_##state: return #state 64 switch (state) { 65 MEI_HBM_STATE(IDLE); 66 MEI_HBM_STATE(STARTING); 67 MEI_HBM_STATE(STARTED); 68 MEI_HBM_STATE(ENUM_CLIENTS); 69 MEI_HBM_STATE(CLIENT_PROPERTIES); 70 MEI_HBM_STATE(STOPPED); 71 default: 72 return "unknown"; 73 } 74 #undef MEI_HBM_STATE 75 } 76 77 /** 78 * mei_cl_conn_status_to_errno - convert client connect response 79 * status to error code 80 * 81 * @status: client connect response status 82 * 83 * Return: corresponding error code 84 */ 85 static int mei_cl_conn_status_to_errno(enum mei_cl_connect_status status) 86 { 87 switch (status) { 88 case MEI_CL_CONN_SUCCESS: return 0; 89 case MEI_CL_CONN_NOT_FOUND: return -ENOTTY; 90 case MEI_CL_CONN_ALREADY_STARTED: return -EBUSY; 91 case MEI_CL_CONN_OUT_OF_RESOURCES: return -EBUSY; 92 case MEI_CL_CONN_MESSAGE_SMALL: return -EINVAL; 93 case MEI_CL_CONN_NOT_ALLOWED: return -EBUSY; 94 default: return -EINVAL; 95 } 96 } 97 98 /** 99 * mei_hbm_write_message - wrapper for sending hbm messages. 100 * 101 * @dev: mei device 102 * @hdr: mei header 103 * @data: payload 104 */ 105 static inline int mei_hbm_write_message(struct mei_device *dev, 106 struct mei_msg_hdr *hdr, 107 const void *data) 108 { 109 return mei_write_message(dev, hdr, sizeof(*hdr), data, hdr->length); 110 } 111 112 /** 113 * mei_hbm_idle - set hbm to idle state 114 * 115 * @dev: the device structure 116 */ 117 void mei_hbm_idle(struct mei_device *dev) 118 { 119 dev->init_clients_timer = 0; 120 dev->hbm_state = MEI_HBM_IDLE; 121 } 122 123 /** 124 * mei_hbm_reset - reset hbm counters and book keeping data structurs 125 * 126 * @dev: the device structure 127 */ 128 void mei_hbm_reset(struct mei_device *dev) 129 { 130 mei_me_cl_rm_all(dev); 131 132 mei_hbm_idle(dev); 133 } 134 135 /** 136 * mei_hbm_hdr - construct hbm header 137 * 138 * @hdr: hbm header 139 * @length: payload length 140 */ 141 142 static inline void mei_hbm_hdr(struct mei_msg_hdr *hdr, size_t length) 143 { 144 hdr->host_addr = 0; 145 hdr->me_addr = 0; 146 hdr->length = length; 147 hdr->msg_complete = 1; 148 hdr->dma_ring = 0; 149 hdr->reserved = 0; 150 hdr->internal = 0; 151 } 152 153 /** 154 * mei_hbm_cl_hdr - construct client hbm header 155 * 156 * @cl: client 157 * @hbm_cmd: host bus message command 158 * @buf: buffer for cl header 159 * @len: buffer length 160 */ 161 static inline 162 void mei_hbm_cl_hdr(struct mei_cl *cl, u8 hbm_cmd, void *buf, size_t len) 163 { 164 struct mei_hbm_cl_cmd *cmd = buf; 165 166 memset(cmd, 0, len); 167 168 cmd->hbm_cmd = hbm_cmd; 169 cmd->host_addr = mei_cl_host_addr(cl); 170 cmd->me_addr = mei_cl_me_id(cl); 171 } 172 173 /** 174 * mei_hbm_cl_write - write simple hbm client message 175 * 176 * @dev: the device structure 177 * @cl: client 178 * @hbm_cmd: host bus message command 179 * @buf: message buffer 180 * @len: buffer length 181 * 182 * Return: 0 on success, <0 on failure. 183 */ 184 static inline int mei_hbm_cl_write(struct mei_device *dev, struct mei_cl *cl, 185 u8 hbm_cmd, void *buf, size_t len) 186 { 187 struct mei_msg_hdr mei_hdr; 188 189 mei_hbm_hdr(&mei_hdr, len); 190 mei_hbm_cl_hdr(cl, hbm_cmd, buf, len); 191 192 return mei_hbm_write_message(dev, &mei_hdr, buf); 193 } 194 195 /** 196 * mei_hbm_cl_addr_equal - check if the client's and 197 * the message address match 198 * 199 * @cl: client 200 * @cmd: hbm client message 201 * 202 * Return: true if addresses are the same 203 */ 204 static inline 205 bool mei_hbm_cl_addr_equal(struct mei_cl *cl, struct mei_hbm_cl_cmd *cmd) 206 { 207 return mei_cl_host_addr(cl) == cmd->host_addr && 208 mei_cl_me_id(cl) == cmd->me_addr; 209 } 210 211 /** 212 * mei_hbm_cl_find_by_cmd - find recipient client 213 * 214 * @dev: the device structure 215 * @buf: a buffer with hbm cl command 216 * 217 * Return: the recipient client or NULL if not found 218 */ 219 static inline 220 struct mei_cl *mei_hbm_cl_find_by_cmd(struct mei_device *dev, void *buf) 221 { 222 struct mei_hbm_cl_cmd *cmd = (struct mei_hbm_cl_cmd *)buf; 223 struct mei_cl *cl; 224 225 list_for_each_entry(cl, &dev->file_list, link) 226 if (mei_hbm_cl_addr_equal(cl, cmd)) 227 return cl; 228 return NULL; 229 } 230 231 232 /** 233 * mei_hbm_start_wait - wait for start response message. 234 * 235 * @dev: the device structure 236 * 237 * Return: 0 on success and < 0 on failure 238 */ 239 int mei_hbm_start_wait(struct mei_device *dev) 240 { 241 int ret; 242 243 if (dev->hbm_state > MEI_HBM_STARTING) 244 return 0; 245 246 mutex_unlock(&dev->device_lock); 247 ret = wait_event_timeout(dev->wait_hbm_start, 248 dev->hbm_state != MEI_HBM_STARTING, 249 mei_secs_to_jiffies(MEI_HBM_TIMEOUT)); 250 mutex_lock(&dev->device_lock); 251 252 if (ret == 0 && (dev->hbm_state <= MEI_HBM_STARTING)) { 253 dev->hbm_state = MEI_HBM_IDLE; 254 dev_err(dev->dev, "waiting for mei start failed\n"); 255 return -ETIME; 256 } 257 return 0; 258 } 259 260 /** 261 * mei_hbm_start_req - sends start request message. 262 * 263 * @dev: the device structure 264 * 265 * Return: 0 on success and < 0 on failure 266 */ 267 int mei_hbm_start_req(struct mei_device *dev) 268 { 269 struct mei_msg_hdr mei_hdr; 270 struct hbm_host_version_request start_req; 271 const size_t len = sizeof(struct hbm_host_version_request); 272 int ret; 273 274 mei_hbm_reset(dev); 275 276 mei_hbm_hdr(&mei_hdr, len); 277 278 /* host start message */ 279 memset(&start_req, 0, len); 280 start_req.hbm_cmd = HOST_START_REQ_CMD; 281 start_req.host_version.major_version = HBM_MAJOR_VERSION; 282 start_req.host_version.minor_version = HBM_MINOR_VERSION; 283 284 dev->hbm_state = MEI_HBM_IDLE; 285 ret = mei_hbm_write_message(dev, &mei_hdr, &start_req); 286 if (ret) { 287 dev_err(dev->dev, "version message write failed: ret = %d\n", 288 ret); 289 return ret; 290 } 291 292 dev->hbm_state = MEI_HBM_STARTING; 293 dev->init_clients_timer = MEI_CLIENTS_INIT_TIMEOUT; 294 mei_schedule_stall_timer(dev); 295 return 0; 296 } 297 298 /** 299 * mei_hbm_enum_clients_req - sends enumeration client request message. 300 * 301 * @dev: the device structure 302 * 303 * Return: 0 on success and < 0 on failure 304 */ 305 static int mei_hbm_enum_clients_req(struct mei_device *dev) 306 { 307 struct mei_msg_hdr mei_hdr; 308 struct hbm_host_enum_request enum_req; 309 const size_t len = sizeof(struct hbm_host_enum_request); 310 int ret; 311 312 /* enumerate clients */ 313 mei_hbm_hdr(&mei_hdr, len); 314 315 memset(&enum_req, 0, len); 316 enum_req.hbm_cmd = HOST_ENUM_REQ_CMD; 317 enum_req.flags |= dev->hbm_f_dc_supported ? 318 MEI_HBM_ENUM_F_ALLOW_ADD : 0; 319 enum_req.flags |= dev->hbm_f_ie_supported ? 320 MEI_HBM_ENUM_F_IMMEDIATE_ENUM : 0; 321 322 ret = mei_hbm_write_message(dev, &mei_hdr, &enum_req); 323 if (ret) { 324 dev_err(dev->dev, "enumeration request write failed: ret = %d.\n", 325 ret); 326 return ret; 327 } 328 dev->hbm_state = MEI_HBM_ENUM_CLIENTS; 329 dev->init_clients_timer = MEI_CLIENTS_INIT_TIMEOUT; 330 mei_schedule_stall_timer(dev); 331 return 0; 332 } 333 334 /** 335 * mei_hbm_me_cl_add - add new me client to the list 336 * 337 * @dev: the device structure 338 * @res: hbm property response 339 * 340 * Return: 0 on success and -ENOMEM on allocation failure 341 */ 342 343 static int mei_hbm_me_cl_add(struct mei_device *dev, 344 struct hbm_props_response *res) 345 { 346 struct mei_me_client *me_cl; 347 const uuid_le *uuid = &res->client_properties.protocol_name; 348 349 mei_me_cl_rm_by_uuid(dev, uuid); 350 351 me_cl = kzalloc(sizeof(struct mei_me_client), GFP_KERNEL); 352 if (!me_cl) 353 return -ENOMEM; 354 355 mei_me_cl_init(me_cl); 356 357 me_cl->props = res->client_properties; 358 me_cl->client_id = res->me_addr; 359 me_cl->tx_flow_ctrl_creds = 0; 360 361 mei_me_cl_add(dev, me_cl); 362 363 return 0; 364 } 365 366 /** 367 * mei_hbm_add_cl_resp - send response to fw on client add request 368 * 369 * @dev: the device structure 370 * @addr: me address 371 * @status: response status 372 * 373 * Return: 0 on success and < 0 on failure 374 */ 375 static int mei_hbm_add_cl_resp(struct mei_device *dev, u8 addr, u8 status) 376 { 377 struct mei_msg_hdr mei_hdr; 378 struct hbm_add_client_response resp; 379 const size_t len = sizeof(struct hbm_add_client_response); 380 int ret; 381 382 dev_dbg(dev->dev, "adding client response\n"); 383 384 mei_hbm_hdr(&mei_hdr, len); 385 386 memset(&resp, 0, sizeof(struct hbm_add_client_response)); 387 resp.hbm_cmd = MEI_HBM_ADD_CLIENT_RES_CMD; 388 resp.me_addr = addr; 389 resp.status = status; 390 391 ret = mei_hbm_write_message(dev, &mei_hdr, &resp); 392 if (ret) 393 dev_err(dev->dev, "add client response write failed: ret = %d\n", 394 ret); 395 return ret; 396 } 397 398 /** 399 * mei_hbm_fw_add_cl_req - request from the fw to add a client 400 * 401 * @dev: the device structure 402 * @req: add client request 403 * 404 * Return: 0 on success and < 0 on failure 405 */ 406 static int mei_hbm_fw_add_cl_req(struct mei_device *dev, 407 struct hbm_add_client_request *req) 408 { 409 int ret; 410 u8 status = MEI_HBMS_SUCCESS; 411 412 BUILD_BUG_ON(sizeof(struct hbm_add_client_request) != 413 sizeof(struct hbm_props_response)); 414 415 ret = mei_hbm_me_cl_add(dev, (struct hbm_props_response *)req); 416 if (ret) 417 status = !MEI_HBMS_SUCCESS; 418 419 if (dev->dev_state == MEI_DEV_ENABLED) 420 schedule_work(&dev->bus_rescan_work); 421 422 return mei_hbm_add_cl_resp(dev, req->me_addr, status); 423 } 424 425 /** 426 * mei_hbm_cl_notify_req - send notification request 427 * 428 * @dev: the device structure 429 * @cl: a client to disconnect from 430 * @start: true for start false for stop 431 * 432 * Return: 0 on success and -EIO on write failure 433 */ 434 int mei_hbm_cl_notify_req(struct mei_device *dev, 435 struct mei_cl *cl, u8 start) 436 { 437 438 struct mei_msg_hdr mei_hdr; 439 struct hbm_notification_request req; 440 const size_t len = sizeof(struct hbm_notification_request); 441 int ret; 442 443 mei_hbm_hdr(&mei_hdr, len); 444 mei_hbm_cl_hdr(cl, MEI_HBM_NOTIFY_REQ_CMD, &req, len); 445 446 req.start = start; 447 448 ret = mei_hbm_write_message(dev, &mei_hdr, &req); 449 if (ret) 450 dev_err(dev->dev, "notify request failed: ret = %d\n", ret); 451 452 return ret; 453 } 454 455 /** 456 * notify_res_to_fop - convert notification response to the proper 457 * notification FOP 458 * 459 * @cmd: client notification start response command 460 * 461 * Return: MEI_FOP_NOTIFY_START or MEI_FOP_NOTIFY_STOP; 462 */ 463 static inline enum mei_cb_file_ops notify_res_to_fop(struct mei_hbm_cl_cmd *cmd) 464 { 465 struct hbm_notification_response *rs = 466 (struct hbm_notification_response *)cmd; 467 468 return mei_cl_notify_req2fop(rs->start); 469 } 470 471 /** 472 * mei_hbm_cl_notify_start_res - update the client state according 473 * notify start response 474 * 475 * @dev: the device structure 476 * @cl: mei host client 477 * @cmd: client notification start response command 478 */ 479 static void mei_hbm_cl_notify_start_res(struct mei_device *dev, 480 struct mei_cl *cl, 481 struct mei_hbm_cl_cmd *cmd) 482 { 483 struct hbm_notification_response *rs = 484 (struct hbm_notification_response *)cmd; 485 486 cl_dbg(dev, cl, "hbm: notify start response status=%d\n", rs->status); 487 488 if (rs->status == MEI_HBMS_SUCCESS || 489 rs->status == MEI_HBMS_ALREADY_STARTED) { 490 cl->notify_en = true; 491 cl->status = 0; 492 } else { 493 cl->status = -EINVAL; 494 } 495 } 496 497 /** 498 * mei_hbm_cl_notify_stop_res - update the client state according 499 * notify stop response 500 * 501 * @dev: the device structure 502 * @cl: mei host client 503 * @cmd: client notification stop response command 504 */ 505 static void mei_hbm_cl_notify_stop_res(struct mei_device *dev, 506 struct mei_cl *cl, 507 struct mei_hbm_cl_cmd *cmd) 508 { 509 struct hbm_notification_response *rs = 510 (struct hbm_notification_response *)cmd; 511 512 cl_dbg(dev, cl, "hbm: notify stop response status=%d\n", rs->status); 513 514 if (rs->status == MEI_HBMS_SUCCESS || 515 rs->status == MEI_HBMS_NOT_STARTED) { 516 cl->notify_en = false; 517 cl->status = 0; 518 } else { 519 /* TODO: spec is not clear yet about other possible issues */ 520 cl->status = -EINVAL; 521 } 522 } 523 524 /** 525 * mei_hbm_cl_notify - signal notification event 526 * 527 * @dev: the device structure 528 * @cmd: notification client message 529 */ 530 static void mei_hbm_cl_notify(struct mei_device *dev, 531 struct mei_hbm_cl_cmd *cmd) 532 { 533 struct mei_cl *cl; 534 535 cl = mei_hbm_cl_find_by_cmd(dev, cmd); 536 if (cl) 537 mei_cl_notify(cl); 538 } 539 540 /** 541 * mei_hbm_prop_req - request property for a single client 542 * 543 * @dev: the device structure 544 * @start_idx: client index to start search 545 * 546 * Return: 0 on success and < 0 on failure 547 */ 548 static int mei_hbm_prop_req(struct mei_device *dev, unsigned long start_idx) 549 { 550 struct mei_msg_hdr mei_hdr; 551 struct hbm_props_request prop_req; 552 const size_t len = sizeof(struct hbm_props_request); 553 unsigned long addr; 554 int ret; 555 556 addr = find_next_bit(dev->me_clients_map, MEI_CLIENTS_MAX, start_idx); 557 558 /* We got all client properties */ 559 if (addr == MEI_CLIENTS_MAX) { 560 dev->hbm_state = MEI_HBM_STARTED; 561 mei_host_client_init(dev); 562 563 return 0; 564 } 565 566 mei_hbm_hdr(&mei_hdr, len); 567 568 memset(&prop_req, 0, sizeof(struct hbm_props_request)); 569 570 prop_req.hbm_cmd = HOST_CLIENT_PROPERTIES_REQ_CMD; 571 prop_req.me_addr = addr; 572 573 ret = mei_hbm_write_message(dev, &mei_hdr, &prop_req); 574 if (ret) { 575 dev_err(dev->dev, "properties request write failed: ret = %d\n", 576 ret); 577 return ret; 578 } 579 580 dev->init_clients_timer = MEI_CLIENTS_INIT_TIMEOUT; 581 mei_schedule_stall_timer(dev); 582 583 return 0; 584 } 585 586 /** 587 * mei_hbm_pg - sends pg command 588 * 589 * @dev: the device structure 590 * @pg_cmd: the pg command code 591 * 592 * Return: -EIO on write failure 593 * -EOPNOTSUPP if the operation is not supported by the protocol 594 */ 595 int mei_hbm_pg(struct mei_device *dev, u8 pg_cmd) 596 { 597 struct mei_msg_hdr mei_hdr; 598 struct hbm_power_gate req; 599 const size_t len = sizeof(struct hbm_power_gate); 600 int ret; 601 602 if (!dev->hbm_f_pg_supported) 603 return -EOPNOTSUPP; 604 605 mei_hbm_hdr(&mei_hdr, len); 606 607 memset(&req, 0, len); 608 req.hbm_cmd = pg_cmd; 609 610 ret = mei_hbm_write_message(dev, &mei_hdr, &req); 611 if (ret) 612 dev_err(dev->dev, "power gate command write failed.\n"); 613 return ret; 614 } 615 EXPORT_SYMBOL_GPL(mei_hbm_pg); 616 617 /** 618 * mei_hbm_stop_req - send stop request message 619 * 620 * @dev: mei device 621 * 622 * Return: -EIO on write failure 623 */ 624 static int mei_hbm_stop_req(struct mei_device *dev) 625 { 626 struct mei_msg_hdr mei_hdr; 627 struct hbm_host_stop_request req; 628 const size_t len = sizeof(struct hbm_host_stop_request); 629 630 mei_hbm_hdr(&mei_hdr, len); 631 632 memset(&req, 0, len); 633 req.hbm_cmd = HOST_STOP_REQ_CMD; 634 req.reason = DRIVER_STOP_REQUEST; 635 636 return mei_hbm_write_message(dev, &mei_hdr, &req); 637 } 638 639 /** 640 * mei_hbm_cl_flow_control_req - sends flow control request. 641 * 642 * @dev: the device structure 643 * @cl: client info 644 * 645 * Return: -EIO on write failure 646 */ 647 int mei_hbm_cl_flow_control_req(struct mei_device *dev, struct mei_cl *cl) 648 { 649 struct hbm_flow_control req; 650 651 cl_dbg(dev, cl, "sending flow control\n"); 652 return mei_hbm_cl_write(dev, cl, MEI_FLOW_CONTROL_CMD, 653 &req, sizeof(req)); 654 } 655 656 /** 657 * mei_hbm_add_single_tx_flow_ctrl_creds - adds single buffer credentials. 658 * 659 * @dev: the device structure 660 * @fctrl: flow control response bus message 661 * 662 * Return: 0 on success, < 0 otherwise 663 */ 664 static int mei_hbm_add_single_tx_flow_ctrl_creds(struct mei_device *dev, 665 struct hbm_flow_control *fctrl) 666 { 667 struct mei_me_client *me_cl; 668 int rets; 669 670 me_cl = mei_me_cl_by_id(dev, fctrl->me_addr); 671 if (!me_cl) { 672 dev_err(dev->dev, "no such me client %d\n", fctrl->me_addr); 673 return -ENOENT; 674 } 675 676 if (WARN_ON(me_cl->props.single_recv_buf == 0)) { 677 rets = -EINVAL; 678 goto out; 679 } 680 681 me_cl->tx_flow_ctrl_creds++; 682 dev_dbg(dev->dev, "recv flow ctrl msg ME %d (single) creds = %d.\n", 683 fctrl->me_addr, me_cl->tx_flow_ctrl_creds); 684 685 rets = 0; 686 out: 687 mei_me_cl_put(me_cl); 688 return rets; 689 } 690 691 /** 692 * mei_hbm_cl_flow_control_res - flow control response from me 693 * 694 * @dev: the device structure 695 * @fctrl: flow control response bus message 696 */ 697 static void mei_hbm_cl_tx_flow_ctrl_creds_res(struct mei_device *dev, 698 struct hbm_flow_control *fctrl) 699 { 700 struct mei_cl *cl; 701 702 if (!fctrl->host_addr) { 703 /* single receive buffer */ 704 mei_hbm_add_single_tx_flow_ctrl_creds(dev, fctrl); 705 return; 706 } 707 708 cl = mei_hbm_cl_find_by_cmd(dev, fctrl); 709 if (cl) { 710 cl->tx_flow_ctrl_creds++; 711 cl_dbg(dev, cl, "flow control creds = %d.\n", 712 cl->tx_flow_ctrl_creds); 713 } 714 } 715 716 717 /** 718 * mei_hbm_cl_disconnect_req - sends disconnect message to fw. 719 * 720 * @dev: the device structure 721 * @cl: a client to disconnect from 722 * 723 * Return: -EIO on write failure 724 */ 725 int mei_hbm_cl_disconnect_req(struct mei_device *dev, struct mei_cl *cl) 726 { 727 struct hbm_client_connect_request req; 728 729 return mei_hbm_cl_write(dev, cl, CLIENT_DISCONNECT_REQ_CMD, 730 &req, sizeof(req)); 731 } 732 733 /** 734 * mei_hbm_cl_disconnect_rsp - sends disconnect respose to the FW 735 * 736 * @dev: the device structure 737 * @cl: a client to disconnect from 738 * 739 * Return: -EIO on write failure 740 */ 741 int mei_hbm_cl_disconnect_rsp(struct mei_device *dev, struct mei_cl *cl) 742 { 743 struct hbm_client_connect_response resp; 744 745 return mei_hbm_cl_write(dev, cl, CLIENT_DISCONNECT_RES_CMD, 746 &resp, sizeof(resp)); 747 } 748 749 /** 750 * mei_hbm_cl_disconnect_res - update the client state according 751 * disconnect response 752 * 753 * @dev: the device structure 754 * @cl: mei host client 755 * @cmd: disconnect client response host bus message 756 */ 757 static void mei_hbm_cl_disconnect_res(struct mei_device *dev, struct mei_cl *cl, 758 struct mei_hbm_cl_cmd *cmd) 759 { 760 struct hbm_client_connect_response *rs = 761 (struct hbm_client_connect_response *)cmd; 762 763 cl_dbg(dev, cl, "hbm: disconnect response status=%d\n", rs->status); 764 765 if (rs->status == MEI_CL_DISCONN_SUCCESS) 766 cl->state = MEI_FILE_DISCONNECT_REPLY; 767 cl->status = 0; 768 } 769 770 /** 771 * mei_hbm_cl_connect_req - send connection request to specific me client 772 * 773 * @dev: the device structure 774 * @cl: a client to connect to 775 * 776 * Return: -EIO on write failure 777 */ 778 int mei_hbm_cl_connect_req(struct mei_device *dev, struct mei_cl *cl) 779 { 780 struct hbm_client_connect_request req; 781 782 return mei_hbm_cl_write(dev, cl, CLIENT_CONNECT_REQ_CMD, 783 &req, sizeof(req)); 784 } 785 786 /** 787 * mei_hbm_cl_connect_res - update the client state according 788 * connection response 789 * 790 * @dev: the device structure 791 * @cl: mei host client 792 * @cmd: connect client response host bus message 793 */ 794 static void mei_hbm_cl_connect_res(struct mei_device *dev, struct mei_cl *cl, 795 struct mei_hbm_cl_cmd *cmd) 796 { 797 struct hbm_client_connect_response *rs = 798 (struct hbm_client_connect_response *)cmd; 799 800 cl_dbg(dev, cl, "hbm: connect response status=%s\n", 801 mei_cl_conn_status_str(rs->status)); 802 803 if (rs->status == MEI_CL_CONN_SUCCESS) 804 cl->state = MEI_FILE_CONNECTED; 805 else { 806 cl->state = MEI_FILE_DISCONNECT_REPLY; 807 if (rs->status == MEI_CL_CONN_NOT_FOUND) { 808 mei_me_cl_del(dev, cl->me_cl); 809 if (dev->dev_state == MEI_DEV_ENABLED) 810 schedule_work(&dev->bus_rescan_work); 811 } 812 } 813 cl->status = mei_cl_conn_status_to_errno(rs->status); 814 } 815 816 /** 817 * mei_hbm_cl_res - process hbm response received on behalf 818 * an client 819 * 820 * @dev: the device structure 821 * @rs: hbm client message 822 * @fop_type: file operation type 823 */ 824 static void mei_hbm_cl_res(struct mei_device *dev, 825 struct mei_hbm_cl_cmd *rs, 826 enum mei_cb_file_ops fop_type) 827 { 828 struct mei_cl *cl; 829 struct mei_cl_cb *cb, *next; 830 831 cl = NULL; 832 list_for_each_entry_safe(cb, next, &dev->ctrl_rd_list, list) { 833 834 cl = cb->cl; 835 836 if (cb->fop_type != fop_type) 837 continue; 838 839 if (mei_hbm_cl_addr_equal(cl, rs)) { 840 list_del_init(&cb->list); 841 break; 842 } 843 } 844 845 if (!cl) 846 return; 847 848 switch (fop_type) { 849 case MEI_FOP_CONNECT: 850 mei_hbm_cl_connect_res(dev, cl, rs); 851 break; 852 case MEI_FOP_DISCONNECT: 853 mei_hbm_cl_disconnect_res(dev, cl, rs); 854 break; 855 case MEI_FOP_NOTIFY_START: 856 mei_hbm_cl_notify_start_res(dev, cl, rs); 857 break; 858 case MEI_FOP_NOTIFY_STOP: 859 mei_hbm_cl_notify_stop_res(dev, cl, rs); 860 break; 861 default: 862 return; 863 } 864 865 cl->timer_count = 0; 866 wake_up(&cl->wait); 867 } 868 869 870 /** 871 * mei_hbm_fw_disconnect_req - disconnect request initiated by ME firmware 872 * host sends disconnect response 873 * 874 * @dev: the device structure. 875 * @disconnect_req: disconnect request bus message from the me 876 * 877 * Return: -ENOMEM on allocation failure 878 */ 879 static int mei_hbm_fw_disconnect_req(struct mei_device *dev, 880 struct hbm_client_connect_request *disconnect_req) 881 { 882 struct mei_cl *cl; 883 struct mei_cl_cb *cb; 884 885 cl = mei_hbm_cl_find_by_cmd(dev, disconnect_req); 886 if (cl) { 887 cl_warn(dev, cl, "fw disconnect request received\n"); 888 cl->state = MEI_FILE_DISCONNECTING; 889 cl->timer_count = 0; 890 891 cb = mei_cl_enqueue_ctrl_wr_cb(cl, 0, MEI_FOP_DISCONNECT_RSP, 892 NULL); 893 if (!cb) 894 return -ENOMEM; 895 } 896 return 0; 897 } 898 899 /** 900 * mei_hbm_pg_enter_res - PG enter response received 901 * 902 * @dev: the device structure. 903 * 904 * Return: 0 on success, -EPROTO on state mismatch 905 */ 906 static int mei_hbm_pg_enter_res(struct mei_device *dev) 907 { 908 if (mei_pg_state(dev) != MEI_PG_OFF || 909 dev->pg_event != MEI_PG_EVENT_WAIT) { 910 dev_err(dev->dev, "hbm: pg entry response: state mismatch [%s, %d]\n", 911 mei_pg_state_str(mei_pg_state(dev)), dev->pg_event); 912 return -EPROTO; 913 } 914 915 dev->pg_event = MEI_PG_EVENT_RECEIVED; 916 wake_up(&dev->wait_pg); 917 918 return 0; 919 } 920 921 /** 922 * mei_hbm_pg_resume - process with PG resume 923 * 924 * @dev: the device structure. 925 */ 926 void mei_hbm_pg_resume(struct mei_device *dev) 927 { 928 pm_request_resume(dev->dev); 929 } 930 EXPORT_SYMBOL_GPL(mei_hbm_pg_resume); 931 932 /** 933 * mei_hbm_pg_exit_res - PG exit response received 934 * 935 * @dev: the device structure. 936 * 937 * Return: 0 on success, -EPROTO on state mismatch 938 */ 939 static int mei_hbm_pg_exit_res(struct mei_device *dev) 940 { 941 if (mei_pg_state(dev) != MEI_PG_ON || 942 (dev->pg_event != MEI_PG_EVENT_WAIT && 943 dev->pg_event != MEI_PG_EVENT_IDLE)) { 944 dev_err(dev->dev, "hbm: pg exit response: state mismatch [%s, %d]\n", 945 mei_pg_state_str(mei_pg_state(dev)), dev->pg_event); 946 return -EPROTO; 947 } 948 949 switch (dev->pg_event) { 950 case MEI_PG_EVENT_WAIT: 951 dev->pg_event = MEI_PG_EVENT_RECEIVED; 952 wake_up(&dev->wait_pg); 953 break; 954 case MEI_PG_EVENT_IDLE: 955 /* 956 * If the driver is not waiting on this then 957 * this is HW initiated exit from PG. 958 * Start runtime pm resume sequence to exit from PG. 959 */ 960 dev->pg_event = MEI_PG_EVENT_RECEIVED; 961 mei_hbm_pg_resume(dev); 962 break; 963 default: 964 WARN(1, "hbm: pg exit response: unexpected pg event = %d\n", 965 dev->pg_event); 966 return -EPROTO; 967 } 968 969 return 0; 970 } 971 972 /** 973 * mei_hbm_config_features - check what hbm features and commands 974 * are supported by the fw 975 * 976 * @dev: the device structure 977 */ 978 static void mei_hbm_config_features(struct mei_device *dev) 979 { 980 /* Power Gating Isolation Support */ 981 dev->hbm_f_pg_supported = 0; 982 if (dev->version.major_version > HBM_MAJOR_VERSION_PGI) 983 dev->hbm_f_pg_supported = 1; 984 985 if (dev->version.major_version == HBM_MAJOR_VERSION_PGI && 986 dev->version.minor_version >= HBM_MINOR_VERSION_PGI) 987 dev->hbm_f_pg_supported = 1; 988 989 if (dev->version.major_version >= HBM_MAJOR_VERSION_DC) 990 dev->hbm_f_dc_supported = 1; 991 992 if (dev->version.major_version >= HBM_MAJOR_VERSION_IE) 993 dev->hbm_f_ie_supported = 1; 994 995 /* disconnect on connect timeout instead of link reset */ 996 if (dev->version.major_version >= HBM_MAJOR_VERSION_DOT) 997 dev->hbm_f_dot_supported = 1; 998 999 /* Notification Event Support */ 1000 if (dev->version.major_version >= HBM_MAJOR_VERSION_EV) 1001 dev->hbm_f_ev_supported = 1; 1002 1003 /* Fixed Address Client Support */ 1004 if (dev->version.major_version >= HBM_MAJOR_VERSION_FA) 1005 dev->hbm_f_fa_supported = 1; 1006 1007 /* OS ver message Support */ 1008 if (dev->version.major_version >= HBM_MAJOR_VERSION_OS) 1009 dev->hbm_f_os_supported = 1; 1010 1011 /* DMA Ring Support */ 1012 if (dev->version.major_version > HBM_MAJOR_VERSION_DR || 1013 (dev->version.major_version == HBM_MAJOR_VERSION_DR && 1014 dev->version.minor_version >= HBM_MINOR_VERSION_DR)) 1015 dev->hbm_f_dr_supported = 1; 1016 } 1017 1018 /** 1019 * mei_hbm_version_is_supported - checks whether the driver can 1020 * support the hbm version of the device 1021 * 1022 * @dev: the device structure 1023 * Return: true if driver can support hbm version of the device 1024 */ 1025 bool mei_hbm_version_is_supported(struct mei_device *dev) 1026 { 1027 return (dev->version.major_version < HBM_MAJOR_VERSION) || 1028 (dev->version.major_version == HBM_MAJOR_VERSION && 1029 dev->version.minor_version <= HBM_MINOR_VERSION); 1030 } 1031 1032 /** 1033 * mei_hbm_dispatch - bottom half read routine after ISR to 1034 * handle the read bus message cmd processing. 1035 * 1036 * @dev: the device structure 1037 * @hdr: header of bus message 1038 * 1039 * Return: 0 on success and < 0 on failure 1040 */ 1041 int mei_hbm_dispatch(struct mei_device *dev, struct mei_msg_hdr *hdr) 1042 { 1043 struct mei_bus_message *mei_msg; 1044 struct hbm_host_version_response *version_res; 1045 struct hbm_props_response *props_res; 1046 struct hbm_host_enum_response *enum_res; 1047 struct hbm_add_client_request *add_cl_req; 1048 int ret; 1049 1050 struct mei_hbm_cl_cmd *cl_cmd; 1051 struct hbm_client_connect_request *disconnect_req; 1052 struct hbm_flow_control *fctrl; 1053 1054 /* read the message to our buffer */ 1055 BUG_ON(hdr->length >= sizeof(dev->rd_msg_buf)); 1056 mei_read_slots(dev, dev->rd_msg_buf, hdr->length); 1057 mei_msg = (struct mei_bus_message *)dev->rd_msg_buf; 1058 cl_cmd = (struct mei_hbm_cl_cmd *)mei_msg; 1059 1060 /* ignore spurious message and prevent reset nesting 1061 * hbm is put to idle during system reset 1062 */ 1063 if (dev->hbm_state == MEI_HBM_IDLE) { 1064 dev_dbg(dev->dev, "hbm: state is idle ignore spurious messages\n"); 1065 return 0; 1066 } 1067 1068 switch (mei_msg->hbm_cmd) { 1069 case HOST_START_RES_CMD: 1070 dev_dbg(dev->dev, "hbm: start: response message received.\n"); 1071 1072 dev->init_clients_timer = 0; 1073 1074 version_res = (struct hbm_host_version_response *)mei_msg; 1075 1076 dev_dbg(dev->dev, "HBM VERSION: DRIVER=%02d:%02d DEVICE=%02d:%02d\n", 1077 HBM_MAJOR_VERSION, HBM_MINOR_VERSION, 1078 version_res->me_max_version.major_version, 1079 version_res->me_max_version.minor_version); 1080 1081 if (version_res->host_version_supported) { 1082 dev->version.major_version = HBM_MAJOR_VERSION; 1083 dev->version.minor_version = HBM_MINOR_VERSION; 1084 } else { 1085 dev->version.major_version = 1086 version_res->me_max_version.major_version; 1087 dev->version.minor_version = 1088 version_res->me_max_version.minor_version; 1089 } 1090 1091 if (!mei_hbm_version_is_supported(dev)) { 1092 dev_warn(dev->dev, "hbm: start: version mismatch - stopping the driver.\n"); 1093 1094 dev->hbm_state = MEI_HBM_STOPPED; 1095 if (mei_hbm_stop_req(dev)) { 1096 dev_err(dev->dev, "hbm: start: failed to send stop request\n"); 1097 return -EIO; 1098 } 1099 break; 1100 } 1101 1102 mei_hbm_config_features(dev); 1103 1104 if (dev->dev_state != MEI_DEV_INIT_CLIENTS || 1105 dev->hbm_state != MEI_HBM_STARTING) { 1106 dev_err(dev->dev, "hbm: start: state mismatch, [%d, %d]\n", 1107 dev->dev_state, dev->hbm_state); 1108 return -EPROTO; 1109 } 1110 1111 if (mei_hbm_enum_clients_req(dev)) { 1112 dev_err(dev->dev, "hbm: start: failed to send enumeration request\n"); 1113 return -EIO; 1114 } 1115 1116 wake_up(&dev->wait_hbm_start); 1117 break; 1118 1119 case CLIENT_CONNECT_RES_CMD: 1120 dev_dbg(dev->dev, "hbm: client connect response: message received.\n"); 1121 mei_hbm_cl_res(dev, cl_cmd, MEI_FOP_CONNECT); 1122 break; 1123 1124 case CLIENT_DISCONNECT_RES_CMD: 1125 dev_dbg(dev->dev, "hbm: client disconnect response: message received.\n"); 1126 mei_hbm_cl_res(dev, cl_cmd, MEI_FOP_DISCONNECT); 1127 break; 1128 1129 case MEI_FLOW_CONTROL_CMD: 1130 dev_dbg(dev->dev, "hbm: client flow control response: message received.\n"); 1131 1132 fctrl = (struct hbm_flow_control *)mei_msg; 1133 mei_hbm_cl_tx_flow_ctrl_creds_res(dev, fctrl); 1134 break; 1135 1136 case MEI_PG_ISOLATION_ENTRY_RES_CMD: 1137 dev_dbg(dev->dev, "hbm: power gate isolation entry response received\n"); 1138 ret = mei_hbm_pg_enter_res(dev); 1139 if (ret) 1140 return ret; 1141 break; 1142 1143 case MEI_PG_ISOLATION_EXIT_REQ_CMD: 1144 dev_dbg(dev->dev, "hbm: power gate isolation exit request received\n"); 1145 ret = mei_hbm_pg_exit_res(dev); 1146 if (ret) 1147 return ret; 1148 break; 1149 1150 case HOST_CLIENT_PROPERTIES_RES_CMD: 1151 dev_dbg(dev->dev, "hbm: properties response: message received.\n"); 1152 1153 dev->init_clients_timer = 0; 1154 1155 if (dev->dev_state != MEI_DEV_INIT_CLIENTS || 1156 dev->hbm_state != MEI_HBM_CLIENT_PROPERTIES) { 1157 dev_err(dev->dev, "hbm: properties response: state mismatch, [%d, %d]\n", 1158 dev->dev_state, dev->hbm_state); 1159 return -EPROTO; 1160 } 1161 1162 props_res = (struct hbm_props_response *)mei_msg; 1163 1164 if (props_res->status == MEI_HBMS_CLIENT_NOT_FOUND) { 1165 dev_dbg(dev->dev, "hbm: properties response: %d CLIENT_NOT_FOUND\n", 1166 props_res->me_addr); 1167 } else if (props_res->status) { 1168 dev_err(dev->dev, "hbm: properties response: wrong status = %d %s\n", 1169 props_res->status, 1170 mei_hbm_status_str(props_res->status)); 1171 return -EPROTO; 1172 } else { 1173 mei_hbm_me_cl_add(dev, props_res); 1174 } 1175 1176 /* request property for the next client */ 1177 if (mei_hbm_prop_req(dev, props_res->me_addr + 1)) 1178 return -EIO; 1179 1180 break; 1181 1182 case HOST_ENUM_RES_CMD: 1183 dev_dbg(dev->dev, "hbm: enumeration response: message received\n"); 1184 1185 dev->init_clients_timer = 0; 1186 1187 enum_res = (struct hbm_host_enum_response *) mei_msg; 1188 BUILD_BUG_ON(sizeof(dev->me_clients_map) 1189 < sizeof(enum_res->valid_addresses)); 1190 memcpy(dev->me_clients_map, enum_res->valid_addresses, 1191 sizeof(enum_res->valid_addresses)); 1192 1193 if (dev->dev_state != MEI_DEV_INIT_CLIENTS || 1194 dev->hbm_state != MEI_HBM_ENUM_CLIENTS) { 1195 dev_err(dev->dev, "hbm: enumeration response: state mismatch, [%d, %d]\n", 1196 dev->dev_state, dev->hbm_state); 1197 return -EPROTO; 1198 } 1199 1200 dev->hbm_state = MEI_HBM_CLIENT_PROPERTIES; 1201 1202 /* first property request */ 1203 if (mei_hbm_prop_req(dev, 0)) 1204 return -EIO; 1205 1206 break; 1207 1208 case HOST_STOP_RES_CMD: 1209 dev_dbg(dev->dev, "hbm: stop response: message received\n"); 1210 1211 dev->init_clients_timer = 0; 1212 1213 if (dev->hbm_state != MEI_HBM_STOPPED) { 1214 dev_err(dev->dev, "hbm: stop response: state mismatch, [%d, %d]\n", 1215 dev->dev_state, dev->hbm_state); 1216 return -EPROTO; 1217 } 1218 1219 dev->dev_state = MEI_DEV_POWER_DOWN; 1220 dev_info(dev->dev, "hbm: stop response: resetting.\n"); 1221 /* force the reset */ 1222 return -EPROTO; 1223 break; 1224 1225 case CLIENT_DISCONNECT_REQ_CMD: 1226 dev_dbg(dev->dev, "hbm: disconnect request: message received\n"); 1227 1228 disconnect_req = (struct hbm_client_connect_request *)mei_msg; 1229 mei_hbm_fw_disconnect_req(dev, disconnect_req); 1230 break; 1231 1232 case ME_STOP_REQ_CMD: 1233 dev_dbg(dev->dev, "hbm: stop request: message received\n"); 1234 dev->hbm_state = MEI_HBM_STOPPED; 1235 if (mei_hbm_stop_req(dev)) { 1236 dev_err(dev->dev, "hbm: stop request: failed to send stop request\n"); 1237 return -EIO; 1238 } 1239 break; 1240 1241 case MEI_HBM_ADD_CLIENT_REQ_CMD: 1242 dev_dbg(dev->dev, "hbm: add client request received\n"); 1243 /* 1244 * after the host receives the enum_resp 1245 * message clients may be added or removed 1246 */ 1247 if (dev->hbm_state <= MEI_HBM_ENUM_CLIENTS || 1248 dev->hbm_state >= MEI_HBM_STOPPED) { 1249 dev_err(dev->dev, "hbm: add client: state mismatch, [%d, %d]\n", 1250 dev->dev_state, dev->hbm_state); 1251 return -EPROTO; 1252 } 1253 add_cl_req = (struct hbm_add_client_request *)mei_msg; 1254 ret = mei_hbm_fw_add_cl_req(dev, add_cl_req); 1255 if (ret) { 1256 dev_err(dev->dev, "hbm: add client: failed to send response %d\n", 1257 ret); 1258 return -EIO; 1259 } 1260 dev_dbg(dev->dev, "hbm: add client request processed\n"); 1261 break; 1262 1263 case MEI_HBM_NOTIFY_RES_CMD: 1264 dev_dbg(dev->dev, "hbm: notify response received\n"); 1265 mei_hbm_cl_res(dev, cl_cmd, notify_res_to_fop(cl_cmd)); 1266 break; 1267 1268 case MEI_HBM_NOTIFICATION_CMD: 1269 dev_dbg(dev->dev, "hbm: notification\n"); 1270 mei_hbm_cl_notify(dev, cl_cmd); 1271 break; 1272 1273 default: 1274 BUG(); 1275 break; 1276 1277 } 1278 return 0; 1279 } 1280 1281