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