1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * ISHTP bus layer messages handling 4 * 5 * Copyright (c) 2003-2016, Intel Corporation. 6 */ 7 8 #include <linux/export.h> 9 #include <linux/slab.h> 10 #include <linux/sched.h> 11 #include <linux/wait.h> 12 #include <linux/spinlock.h> 13 #include "ishtp-dev.h" 14 #include "hbm.h" 15 #include "client.h" 16 17 /** 18 * ishtp_hbm_fw_cl_allocate() - Allocate FW clients 19 * @dev: ISHTP device instance 20 * 21 * Allocates storage for fw clients 22 */ 23 static void ishtp_hbm_fw_cl_allocate(struct ishtp_device *dev) 24 { 25 struct ishtp_fw_client *clients; 26 int b; 27 28 /* count how many ISH clients we have */ 29 for_each_set_bit(b, dev->fw_clients_map, ISHTP_CLIENTS_MAX) 30 dev->fw_clients_num++; 31 32 if (dev->fw_clients_num <= 0) 33 return; 34 35 /* allocate storage for fw clients representation */ 36 clients = kcalloc(dev->fw_clients_num, sizeof(struct ishtp_fw_client), 37 GFP_KERNEL); 38 if (!clients) { 39 dev->dev_state = ISHTP_DEV_RESETTING; 40 ish_hw_reset(dev); 41 return; 42 } 43 dev->fw_clients = clients; 44 } 45 46 /** 47 * ishtp_hbm_cl_hdr() - construct client hbm header 48 * @cl: client 49 * @hbm_cmd: host bus message command 50 * @buf: buffer for cl header 51 * @len: buffer length 52 * 53 * Initialize HBM buffer 54 */ 55 static inline void ishtp_hbm_cl_hdr(struct ishtp_cl *cl, uint8_t hbm_cmd, 56 void *buf, size_t len) 57 { 58 struct ishtp_hbm_cl_cmd *cmd = buf; 59 60 memset(cmd, 0, len); 61 62 cmd->hbm_cmd = hbm_cmd; 63 cmd->host_addr = cl->host_client_id; 64 cmd->fw_addr = cl->fw_client_id; 65 } 66 67 /** 68 * ishtp_hbm_cl_addr_equal() - Compare client address 69 * @cl: client 70 * @buf: Client command buffer 71 * 72 * Compare client address with the address in command buffer 73 * 74 * Return: True if they have the same address 75 */ 76 static inline bool ishtp_hbm_cl_addr_equal(struct ishtp_cl *cl, void *buf) 77 { 78 struct ishtp_hbm_cl_cmd *cmd = buf; 79 80 return cl->host_client_id == cmd->host_addr && 81 cl->fw_client_id == cmd->fw_addr; 82 } 83 84 /** 85 * ishtp_hbm_start_wait() - Wait for HBM start message 86 * @dev: ISHTP device instance 87 * 88 * Wait for HBM start message from firmware 89 * 90 * Return: 0 if HBM start is/was received else timeout error 91 */ 92 int ishtp_hbm_start_wait(struct ishtp_device *dev) 93 { 94 int ret; 95 96 if (dev->hbm_state > ISHTP_HBM_START) 97 return 0; 98 99 dev_dbg(dev->devc, "Going to wait for ishtp start. hbm_state=%08X\n", 100 dev->hbm_state); 101 ret = wait_event_interruptible_timeout(dev->wait_hbm_recvd_msg, 102 dev->hbm_state >= ISHTP_HBM_STARTED, 103 (ISHTP_INTEROP_TIMEOUT * HZ)); 104 105 dev_dbg(dev->devc, 106 "Woke up from waiting for ishtp start. hbm_state=%08X\n", 107 dev->hbm_state); 108 109 if (ret <= 0 && (dev->hbm_state <= ISHTP_HBM_START)) { 110 dev->hbm_state = ISHTP_HBM_IDLE; 111 dev_err(dev->devc, 112 "waiting for ishtp start failed. ret=%d hbm_state=%08X\n", 113 ret, dev->hbm_state); 114 return -ETIMEDOUT; 115 } 116 return 0; 117 } 118 119 /** 120 * ishtp_hbm_start_req() - Send HBM start message 121 * @dev: ISHTP device instance 122 * 123 * Send HBM start message to firmware 124 * 125 * Return: 0 if success else error code 126 */ 127 int ishtp_hbm_start_req(struct ishtp_device *dev) 128 { 129 struct ishtp_msg_hdr hdr; 130 struct hbm_host_version_request start_req = { 0 }; 131 132 ishtp_hbm_hdr(&hdr, sizeof(start_req)); 133 134 /* host start message */ 135 start_req.hbm_cmd = HOST_START_REQ_CMD; 136 start_req.host_version.major_version = HBM_MAJOR_VERSION; 137 start_req.host_version.minor_version = HBM_MINOR_VERSION; 138 139 /* 140 * (!) Response to HBM start may be so quick that this thread would get 141 * preempted BEFORE managing to set hbm_state = ISHTP_HBM_START. 142 * So set it at first, change back to ISHTP_HBM_IDLE upon failure 143 */ 144 dev->hbm_state = ISHTP_HBM_START; 145 if (ishtp_write_message(dev, &hdr, &start_req)) { 146 dev_err(dev->devc, "version message send failed\n"); 147 dev->dev_state = ISHTP_DEV_RESETTING; 148 dev->hbm_state = ISHTP_HBM_IDLE; 149 ish_hw_reset(dev); 150 return -ENODEV; 151 } 152 153 return 0; 154 } 155 156 /** 157 * ishtp_hbm_enum_clients_req() - Send client enum req 158 * @dev: ISHTP device instance 159 * 160 * Send enumeration client request message 161 * 162 * Return: 0 if success else error code 163 */ 164 void ishtp_hbm_enum_clients_req(struct ishtp_device *dev) 165 { 166 struct ishtp_msg_hdr hdr; 167 struct hbm_host_enum_request enum_req = { 0 }; 168 169 /* enumerate clients */ 170 ishtp_hbm_hdr(&hdr, sizeof(enum_req)); 171 enum_req.hbm_cmd = HOST_ENUM_REQ_CMD; 172 173 if (ishtp_write_message(dev, &hdr, &enum_req)) { 174 dev->dev_state = ISHTP_DEV_RESETTING; 175 dev_err(dev->devc, "enumeration request send failed\n"); 176 ish_hw_reset(dev); 177 } 178 dev->hbm_state = ISHTP_HBM_ENUM_CLIENTS; 179 } 180 181 /** 182 * ishtp_hbm_prop_req() - Request property 183 * @dev: ISHTP device instance 184 * 185 * Request property for a single client 186 * 187 * Return: 0 if success else error code 188 */ 189 static int ishtp_hbm_prop_req(struct ishtp_device *dev) 190 { 191 struct ishtp_msg_hdr hdr; 192 struct hbm_props_request prop_req = { 0 }; 193 unsigned long next_client_index; 194 uint8_t client_num; 195 196 client_num = dev->fw_client_presentation_num; 197 198 next_client_index = find_next_bit(dev->fw_clients_map, 199 ISHTP_CLIENTS_MAX, dev->fw_client_index); 200 201 /* We got all client properties */ 202 if (next_client_index == ISHTP_CLIENTS_MAX) { 203 dev->hbm_state = ISHTP_HBM_WORKING; 204 dev->dev_state = ISHTP_DEV_ENABLED; 205 206 for (dev->fw_client_presentation_num = 1; 207 dev->fw_client_presentation_num < client_num + 1; 208 ++dev->fw_client_presentation_num) 209 /* Add new client device */ 210 ishtp_bus_new_client(dev); 211 return 0; 212 } 213 214 dev->fw_clients[client_num].client_id = next_client_index; 215 216 ishtp_hbm_hdr(&hdr, sizeof(prop_req)); 217 218 prop_req.hbm_cmd = HOST_CLIENT_PROPERTIES_REQ_CMD; 219 prop_req.address = next_client_index; 220 221 if (ishtp_write_message(dev, &hdr, &prop_req)) { 222 dev->dev_state = ISHTP_DEV_RESETTING; 223 dev_err(dev->devc, "properties request send failed\n"); 224 ish_hw_reset(dev); 225 return -EIO; 226 } 227 228 dev->fw_client_index = next_client_index; 229 230 return 0; 231 } 232 233 /** 234 * ishtp_hbm_stop_req() - Send HBM stop 235 * @dev: ISHTP device instance 236 * 237 * Send stop request message 238 */ 239 static void ishtp_hbm_stop_req(struct ishtp_device *dev) 240 { 241 struct ishtp_msg_hdr hdr; 242 struct hbm_host_stop_request stop_req = { 0 } ; 243 244 ishtp_hbm_hdr(&hdr, sizeof(stop_req)); 245 246 stop_req.hbm_cmd = HOST_STOP_REQ_CMD; 247 stop_req.reason = DRIVER_STOP_REQUEST; 248 249 ishtp_write_message(dev, &hdr, &stop_req); 250 } 251 252 /** 253 * ishtp_hbm_cl_flow_control_req() - Send flow control request 254 * @dev: ISHTP device instance 255 * @cl: ISHTP client instance 256 * 257 * Send flow control request 258 * 259 * Return: 0 if success else error code 260 */ 261 int ishtp_hbm_cl_flow_control_req(struct ishtp_device *dev, 262 struct ishtp_cl *cl) 263 { 264 struct ishtp_msg_hdr hdr; 265 struct hbm_flow_control flow_ctrl; 266 const size_t len = sizeof(flow_ctrl); 267 int rv; 268 unsigned long flags; 269 270 spin_lock_irqsave(&cl->fc_spinlock, flags); 271 272 ishtp_hbm_hdr(&hdr, len); 273 ishtp_hbm_cl_hdr(cl, ISHTP_FLOW_CONTROL_CMD, &flow_ctrl, len); 274 275 /* 276 * Sync possible race when RB recycle and packet receive paths 277 * both try to send an out FC 278 */ 279 if (cl->out_flow_ctrl_creds) { 280 spin_unlock_irqrestore(&cl->fc_spinlock, flags); 281 return 0; 282 } 283 284 cl->recv_msg_num_frags = 0; 285 286 rv = ishtp_write_message(dev, &hdr, &flow_ctrl); 287 if (!rv) { 288 ++cl->out_flow_ctrl_creds; 289 ++cl->out_flow_ctrl_cnt; 290 cl->ts_out_fc = ktime_get(); 291 if (cl->ts_rx) { 292 ktime_t ts_diff = ktime_sub(cl->ts_out_fc, cl->ts_rx); 293 if (ktime_after(ts_diff, cl->ts_max_fc_delay)) 294 cl->ts_max_fc_delay = ts_diff; 295 } 296 } else { 297 ++cl->err_send_fc; 298 } 299 300 spin_unlock_irqrestore(&cl->fc_spinlock, flags); 301 return rv; 302 } 303 304 /** 305 * ishtp_hbm_cl_disconnect_req() - Send disconnect request 306 * @dev: ISHTP device instance 307 * @cl: ISHTP client instance 308 * 309 * Send disconnect message to fw 310 * 311 * Return: 0 if success else error code 312 */ 313 int ishtp_hbm_cl_disconnect_req(struct ishtp_device *dev, struct ishtp_cl *cl) 314 { 315 struct ishtp_msg_hdr hdr; 316 struct hbm_client_connect_request disconn_req; 317 const size_t len = sizeof(disconn_req); 318 319 ishtp_hbm_hdr(&hdr, len); 320 ishtp_hbm_cl_hdr(cl, CLIENT_DISCONNECT_REQ_CMD, &disconn_req, len); 321 322 return ishtp_write_message(dev, &hdr, &disconn_req); 323 } 324 325 /** 326 * ishtp_hbm_cl_disconnect_res() - Get disconnect response 327 * @dev: ISHTP device instance 328 * @rs: Response message 329 * 330 * Received disconnect response from fw 331 */ 332 static void ishtp_hbm_cl_disconnect_res(struct ishtp_device *dev, 333 struct hbm_client_connect_response *rs) 334 { 335 struct ishtp_cl *cl = NULL; 336 unsigned long flags; 337 338 spin_lock_irqsave(&dev->cl_list_lock, flags); 339 list_for_each_entry(cl, &dev->cl_list, link) { 340 if (!rs->status && ishtp_hbm_cl_addr_equal(cl, rs)) { 341 cl->state = ISHTP_CL_DISCONNECTED; 342 wake_up_interruptible(&cl->wait_ctrl_res); 343 break; 344 } 345 } 346 spin_unlock_irqrestore(&dev->cl_list_lock, flags); 347 } 348 349 /** 350 * ishtp_hbm_cl_connect_req() - Send connect request 351 * @dev: ISHTP device instance 352 * @cl: client device instance 353 * 354 * Send connection request to specific fw client 355 * 356 * Return: 0 if success else error code 357 */ 358 int ishtp_hbm_cl_connect_req(struct ishtp_device *dev, struct ishtp_cl *cl) 359 { 360 struct ishtp_msg_hdr hdr; 361 struct hbm_client_connect_request conn_req; 362 const size_t len = sizeof(conn_req); 363 364 ishtp_hbm_hdr(&hdr, len); 365 ishtp_hbm_cl_hdr(cl, CLIENT_CONNECT_REQ_CMD, &conn_req, len); 366 367 return ishtp_write_message(dev, &hdr, &conn_req); 368 } 369 370 /** 371 * ishtp_hbm_cl_connect_res() - Get connect response 372 * @dev: ISHTP device instance 373 * @rs: Response message 374 * 375 * Received connect response from fw 376 */ 377 static void ishtp_hbm_cl_connect_res(struct ishtp_device *dev, 378 struct hbm_client_connect_response *rs) 379 { 380 struct ishtp_cl *cl = NULL; 381 unsigned long flags; 382 383 spin_lock_irqsave(&dev->cl_list_lock, flags); 384 list_for_each_entry(cl, &dev->cl_list, link) { 385 if (ishtp_hbm_cl_addr_equal(cl, rs)) { 386 if (!rs->status) { 387 cl->state = ISHTP_CL_CONNECTED; 388 cl->status = 0; 389 } else { 390 cl->state = ISHTP_CL_DISCONNECTED; 391 cl->status = -ENODEV; 392 } 393 wake_up_interruptible(&cl->wait_ctrl_res); 394 break; 395 } 396 } 397 spin_unlock_irqrestore(&dev->cl_list_lock, flags); 398 } 399 400 /** 401 * ishtp_client_disconnect_request() - Receive disconnect request 402 * @dev: ISHTP device instance 403 * @disconnect_req: disconnect request structure 404 * 405 * Disconnect request bus message from the fw. Send disconnect response. 406 */ 407 static void ishtp_hbm_fw_disconnect_req(struct ishtp_device *dev, 408 struct hbm_client_connect_request *disconnect_req) 409 { 410 struct ishtp_cl *cl; 411 const size_t len = sizeof(struct hbm_client_connect_response); 412 unsigned long flags; 413 struct ishtp_msg_hdr hdr; 414 unsigned char data[4]; /* All HBM messages are 4 bytes */ 415 416 spin_lock_irqsave(&dev->cl_list_lock, flags); 417 list_for_each_entry(cl, &dev->cl_list, link) { 418 if (ishtp_hbm_cl_addr_equal(cl, disconnect_req)) { 419 cl->state = ISHTP_CL_DISCONNECTED; 420 421 /* send disconnect response */ 422 ishtp_hbm_hdr(&hdr, len); 423 ishtp_hbm_cl_hdr(cl, CLIENT_DISCONNECT_RES_CMD, data, 424 len); 425 ishtp_write_message(dev, &hdr, data); 426 break; 427 } 428 } 429 spin_unlock_irqrestore(&dev->cl_list_lock, flags); 430 } 431 432 /** 433 * ishtp_hbm_dma_xfer_ack(() - Receive transfer ACK 434 * @dev: ISHTP device instance 435 * @dma_xfer: HBM transfer message 436 * 437 * Receive ack for ISHTP-over-DMA client message 438 */ 439 static void ishtp_hbm_dma_xfer_ack(struct ishtp_device *dev, 440 struct dma_xfer_hbm *dma_xfer) 441 { 442 void *msg; 443 uint64_t offs; 444 struct ishtp_msg_hdr *ishtp_hdr = 445 (struct ishtp_msg_hdr *)&dev->ishtp_msg_hdr; 446 unsigned int msg_offs; 447 struct ishtp_cl *cl; 448 449 for (msg_offs = 0; msg_offs < ishtp_hdr->length; 450 msg_offs += sizeof(struct dma_xfer_hbm)) { 451 offs = dma_xfer->msg_addr - dev->ishtp_host_dma_tx_buf_phys; 452 if (offs > dev->ishtp_host_dma_tx_buf_size) { 453 dev_err(dev->devc, "Bad DMA Tx ack message address\n"); 454 return; 455 } 456 if (dma_xfer->msg_length > 457 dev->ishtp_host_dma_tx_buf_size - offs) { 458 dev_err(dev->devc, "Bad DMA Tx ack message size\n"); 459 return; 460 } 461 462 /* logical address of the acked mem */ 463 msg = (unsigned char *)dev->ishtp_host_dma_tx_buf + offs; 464 ishtp_cl_release_dma_acked_mem(dev, msg, dma_xfer->msg_length); 465 466 list_for_each_entry(cl, &dev->cl_list, link) { 467 if (cl->fw_client_id == dma_xfer->fw_client_id && 468 cl->host_client_id == dma_xfer->host_client_id) 469 /* 470 * in case that a single ack may be sent 471 * over several dma transfers, and the last msg 472 * addr was inside the acked memory, but not in 473 * its start 474 */ 475 if (cl->last_dma_addr >= 476 (unsigned char *)msg && 477 cl->last_dma_addr < 478 (unsigned char *)msg + 479 dma_xfer->msg_length) { 480 cl->last_dma_acked = 1; 481 482 if (!list_empty(&cl->tx_list.list) && 483 cl->ishtp_flow_ctrl_creds) { 484 /* 485 * start sending the first msg 486 */ 487 ishtp_cl_send_msg(dev, cl); 488 } 489 } 490 } 491 ++dma_xfer; 492 } 493 } 494 495 /** 496 * ishtp_hbm_dma_xfer() - Receive DMA transfer message 497 * @dev: ISHTP device instance 498 * @dma_xfer: HBM transfer message 499 * 500 * Receive ISHTP-over-DMA client message 501 */ 502 static void ishtp_hbm_dma_xfer(struct ishtp_device *dev, 503 struct dma_xfer_hbm *dma_xfer) 504 { 505 void *msg; 506 uint64_t offs; 507 struct ishtp_msg_hdr hdr; 508 struct ishtp_msg_hdr *ishtp_hdr = 509 (struct ishtp_msg_hdr *) &dev->ishtp_msg_hdr; 510 struct dma_xfer_hbm *prm = dma_xfer; 511 unsigned int msg_offs; 512 513 for (msg_offs = 0; msg_offs < ishtp_hdr->length; 514 msg_offs += sizeof(struct dma_xfer_hbm)) { 515 516 offs = dma_xfer->msg_addr - dev->ishtp_host_dma_rx_buf_phys; 517 if (offs > dev->ishtp_host_dma_rx_buf_size) { 518 dev_err(dev->devc, "Bad DMA Rx message address\n"); 519 return; 520 } 521 if (dma_xfer->msg_length > 522 dev->ishtp_host_dma_rx_buf_size - offs) { 523 dev_err(dev->devc, "Bad DMA Rx message size\n"); 524 return; 525 } 526 msg = dev->ishtp_host_dma_rx_buf + offs; 527 recv_ishtp_cl_msg_dma(dev, msg, dma_xfer); 528 dma_xfer->hbm = DMA_XFER_ACK; /* Prepare for response */ 529 ++dma_xfer; 530 } 531 532 /* Send DMA_XFER_ACK [...] */ 533 ishtp_hbm_hdr(&hdr, ishtp_hdr->length); 534 ishtp_write_message(dev, &hdr, (unsigned char *)prm); 535 } 536 537 /** 538 * ishtp_hbm_dispatch() - HBM dispatch function 539 * @dev: ISHTP device instance 540 * @hdr: bus message 541 * 542 * Bottom half read routine after ISR to handle the read bus message cmd 543 * processing 544 */ 545 void ishtp_hbm_dispatch(struct ishtp_device *dev, 546 struct ishtp_bus_message *hdr) 547 { 548 struct ishtp_bus_message *ishtp_msg; 549 struct ishtp_fw_client *fw_client; 550 struct hbm_host_version_response *version_res; 551 struct hbm_client_connect_response *connect_res; 552 struct hbm_client_connect_response *disconnect_res; 553 struct hbm_client_connect_request *disconnect_req; 554 struct hbm_props_response *props_res; 555 struct hbm_host_enum_response *enum_res; 556 struct ishtp_msg_hdr ishtp_hdr; 557 struct dma_alloc_notify dma_alloc_notify; 558 struct dma_xfer_hbm *dma_xfer; 559 560 ishtp_msg = hdr; 561 562 switch (ishtp_msg->hbm_cmd) { 563 case HOST_START_RES_CMD: 564 version_res = (struct hbm_host_version_response *)ishtp_msg; 565 if (!version_res->host_version_supported) { 566 dev->version = version_res->fw_max_version; 567 568 dev->hbm_state = ISHTP_HBM_STOPPED; 569 ishtp_hbm_stop_req(dev); 570 return; 571 } 572 573 dev->version.major_version = HBM_MAJOR_VERSION; 574 dev->version.minor_version = HBM_MINOR_VERSION; 575 if (dev->dev_state == ISHTP_DEV_INIT_CLIENTS && 576 dev->hbm_state == ISHTP_HBM_START) { 577 dev->hbm_state = ISHTP_HBM_STARTED; 578 ishtp_hbm_enum_clients_req(dev); 579 } else { 580 dev_err(dev->devc, 581 "reset: wrong host start response\n"); 582 /* BUG: why do we arrive here? */ 583 ish_hw_reset(dev); 584 return; 585 } 586 587 wake_up_interruptible(&dev->wait_hbm_recvd_msg); 588 break; 589 590 case CLIENT_CONNECT_RES_CMD: 591 connect_res = (struct hbm_client_connect_response *)ishtp_msg; 592 ishtp_hbm_cl_connect_res(dev, connect_res); 593 break; 594 595 case CLIENT_DISCONNECT_RES_CMD: 596 disconnect_res = 597 (struct hbm_client_connect_response *)ishtp_msg; 598 ishtp_hbm_cl_disconnect_res(dev, disconnect_res); 599 break; 600 601 case HOST_CLIENT_PROPERTIES_RES_CMD: 602 props_res = (struct hbm_props_response *)ishtp_msg; 603 fw_client = &dev->fw_clients[dev->fw_client_presentation_num]; 604 605 if (props_res->status || !dev->fw_clients) { 606 dev_err(dev->devc, 607 "reset: properties response hbm wrong status\n"); 608 ish_hw_reset(dev); 609 return; 610 } 611 612 if (fw_client->client_id != props_res->address) { 613 dev_err(dev->devc, 614 "reset: host properties response address mismatch [%02X %02X]\n", 615 fw_client->client_id, props_res->address); 616 ish_hw_reset(dev); 617 return; 618 } 619 620 if (dev->dev_state != ISHTP_DEV_INIT_CLIENTS || 621 dev->hbm_state != ISHTP_HBM_CLIENT_PROPERTIES) { 622 dev_err(dev->devc, 623 "reset: unexpected properties response\n"); 624 ish_hw_reset(dev); 625 return; 626 } 627 628 fw_client->props = props_res->client_properties; 629 dev->fw_client_index++; 630 dev->fw_client_presentation_num++; 631 632 /* request property for the next client */ 633 ishtp_hbm_prop_req(dev); 634 635 if (dev->dev_state != ISHTP_DEV_ENABLED) 636 break; 637 638 if (!ishtp_use_dma_transfer()) 639 break; 640 641 dev_dbg(dev->devc, "Requesting to use DMA\n"); 642 ishtp_cl_alloc_dma_buf(dev); 643 if (dev->ishtp_host_dma_rx_buf) { 644 const size_t len = sizeof(dma_alloc_notify); 645 646 memset(&dma_alloc_notify, 0, sizeof(dma_alloc_notify)); 647 dma_alloc_notify.hbm = DMA_BUFFER_ALLOC_NOTIFY; 648 dma_alloc_notify.buf_size = 649 dev->ishtp_host_dma_rx_buf_size; 650 dma_alloc_notify.buf_address = 651 dev->ishtp_host_dma_rx_buf_phys; 652 ishtp_hbm_hdr(&ishtp_hdr, len); 653 ishtp_write_message(dev, &ishtp_hdr, 654 (unsigned char *)&dma_alloc_notify); 655 } 656 657 break; 658 659 case HOST_ENUM_RES_CMD: 660 enum_res = (struct hbm_host_enum_response *) ishtp_msg; 661 memcpy(dev->fw_clients_map, enum_res->valid_addresses, 32); 662 if (dev->dev_state == ISHTP_DEV_INIT_CLIENTS && 663 dev->hbm_state == ISHTP_HBM_ENUM_CLIENTS) { 664 dev->fw_client_presentation_num = 0; 665 dev->fw_client_index = 0; 666 667 ishtp_hbm_fw_cl_allocate(dev); 668 dev->hbm_state = ISHTP_HBM_CLIENT_PROPERTIES; 669 670 /* first property request */ 671 ishtp_hbm_prop_req(dev); 672 } else { 673 dev_err(dev->devc, 674 "reset: unexpected enumeration response hbm\n"); 675 ish_hw_reset(dev); 676 return; 677 } 678 break; 679 680 case HOST_STOP_RES_CMD: 681 if (dev->hbm_state != ISHTP_HBM_STOPPED) 682 dev_err(dev->devc, "unexpected stop response\n"); 683 684 dev->dev_state = ISHTP_DEV_DISABLED; 685 dev_info(dev->devc, "reset: FW stop response\n"); 686 ish_hw_reset(dev); 687 break; 688 689 case CLIENT_DISCONNECT_REQ_CMD: 690 /* search for client */ 691 disconnect_req = 692 (struct hbm_client_connect_request *)ishtp_msg; 693 ishtp_hbm_fw_disconnect_req(dev, disconnect_req); 694 break; 695 696 case FW_STOP_REQ_CMD: 697 dev->hbm_state = ISHTP_HBM_STOPPED; 698 break; 699 700 case DMA_BUFFER_ALLOC_RESPONSE: 701 dev->ishtp_host_dma_enabled = 1; 702 break; 703 704 case DMA_XFER: 705 dma_xfer = (struct dma_xfer_hbm *)ishtp_msg; 706 if (!dev->ishtp_host_dma_enabled) { 707 dev_err(dev->devc, 708 "DMA XFER requested but DMA is not enabled\n"); 709 break; 710 } 711 ishtp_hbm_dma_xfer(dev, dma_xfer); 712 break; 713 714 case DMA_XFER_ACK: 715 dma_xfer = (struct dma_xfer_hbm *)ishtp_msg; 716 if (!dev->ishtp_host_dma_enabled || 717 !dev->ishtp_host_dma_tx_buf) { 718 dev_err(dev->devc, 719 "DMA XFER acked but DMA Tx is not enabled\n"); 720 break; 721 } 722 ishtp_hbm_dma_xfer_ack(dev, dma_xfer); 723 break; 724 725 default: 726 dev_err(dev->devc, "unknown HBM: %u\n", 727 (unsigned int)ishtp_msg->hbm_cmd); 728 729 break; 730 } 731 } 732 733 /** 734 * bh_hbm_work_fn() - HBM work function 735 * @work: work struct 736 * 737 * Bottom half processing work function (instead of thread handler) 738 * for processing hbm messages 739 */ 740 void bh_hbm_work_fn(struct work_struct *work) 741 { 742 unsigned long flags; 743 struct ishtp_device *dev; 744 unsigned char hbm[IPC_PAYLOAD_SIZE]; 745 746 dev = container_of(work, struct ishtp_device, bh_hbm_work); 747 spin_lock_irqsave(&dev->rd_msg_spinlock, flags); 748 if (dev->rd_msg_fifo_head != dev->rd_msg_fifo_tail) { 749 memcpy(hbm, dev->rd_msg_fifo + dev->rd_msg_fifo_head, 750 IPC_PAYLOAD_SIZE); 751 dev->rd_msg_fifo_head = 752 (dev->rd_msg_fifo_head + IPC_PAYLOAD_SIZE) % 753 (RD_INT_FIFO_SIZE * IPC_PAYLOAD_SIZE); 754 spin_unlock_irqrestore(&dev->rd_msg_spinlock, flags); 755 ishtp_hbm_dispatch(dev, (struct ishtp_bus_message *)hbm); 756 } else { 757 spin_unlock_irqrestore(&dev->rd_msg_spinlock, flags); 758 } 759 } 760 761 /** 762 * recv_hbm() - Receive HBM message 763 * @dev: ISHTP device instance 764 * @ishtp_hdr: received bus message 765 * 766 * Receive and process ISHTP bus messages in ISR context. This will schedule 767 * work function to process message 768 */ 769 void recv_hbm(struct ishtp_device *dev, struct ishtp_msg_hdr *ishtp_hdr) 770 { 771 uint8_t rd_msg_buf[ISHTP_RD_MSG_BUF_SIZE]; 772 struct ishtp_bus_message *ishtp_msg = 773 (struct ishtp_bus_message *)rd_msg_buf; 774 unsigned long flags; 775 776 dev->ops->ishtp_read(dev, rd_msg_buf, ishtp_hdr->length); 777 778 /* Flow control - handle in place */ 779 if (ishtp_msg->hbm_cmd == ISHTP_FLOW_CONTROL_CMD) { 780 struct hbm_flow_control *flow_control = 781 (struct hbm_flow_control *)ishtp_msg; 782 struct ishtp_cl *cl = NULL; 783 unsigned long flags, tx_flags; 784 785 spin_lock_irqsave(&dev->cl_list_lock, flags); 786 list_for_each_entry(cl, &dev->cl_list, link) { 787 if (cl->host_client_id == flow_control->host_addr && 788 cl->fw_client_id == 789 flow_control->fw_addr) { 790 /* 791 * NOTE: It's valid only for counting 792 * flow-control implementation to receive a 793 * FC in the middle of sending. Meanwhile not 794 * supported 795 */ 796 if (cl->ishtp_flow_ctrl_creds) 797 dev_err(dev->devc, 798 "recv extra FC from FW client %u (host client %u) (FC count was %d)\n", 799 (unsigned int)cl->fw_client_id, 800 (unsigned int)cl->host_client_id, 801 cl->ishtp_flow_ctrl_creds); 802 else { 803 ++cl->ishtp_flow_ctrl_creds; 804 ++cl->ishtp_flow_ctrl_cnt; 805 cl->last_ipc_acked = 1; 806 spin_lock_irqsave( 807 &cl->tx_list_spinlock, 808 tx_flags); 809 if (!list_empty(&cl->tx_list.list)) { 810 /* 811 * start sending the first msg 812 * = the callback function 813 */ 814 spin_unlock_irqrestore( 815 &cl->tx_list_spinlock, 816 tx_flags); 817 ishtp_cl_send_msg(dev, cl); 818 } else { 819 spin_unlock_irqrestore( 820 &cl->tx_list_spinlock, 821 tx_flags); 822 } 823 } 824 break; 825 } 826 } 827 spin_unlock_irqrestore(&dev->cl_list_lock, flags); 828 goto eoi; 829 } 830 831 /* 832 * Some messages that are safe for ISR processing and important 833 * to be done "quickly" and in-order, go here 834 */ 835 if (ishtp_msg->hbm_cmd == CLIENT_CONNECT_RES_CMD || 836 ishtp_msg->hbm_cmd == CLIENT_DISCONNECT_RES_CMD || 837 ishtp_msg->hbm_cmd == CLIENT_DISCONNECT_REQ_CMD || 838 ishtp_msg->hbm_cmd == DMA_XFER) { 839 ishtp_hbm_dispatch(dev, ishtp_msg); 840 goto eoi; 841 } 842 843 /* 844 * All other HBMs go here. 845 * We schedule HBMs for processing serially by using system wq, 846 * possibly there will be multiple HBMs scheduled at the same time. 847 */ 848 spin_lock_irqsave(&dev->rd_msg_spinlock, flags); 849 if ((dev->rd_msg_fifo_tail + IPC_PAYLOAD_SIZE) % 850 (RD_INT_FIFO_SIZE * IPC_PAYLOAD_SIZE) == 851 dev->rd_msg_fifo_head) { 852 spin_unlock_irqrestore(&dev->rd_msg_spinlock, flags); 853 dev_err(dev->devc, "BH buffer overflow, dropping HBM %u\n", 854 (unsigned int)ishtp_msg->hbm_cmd); 855 goto eoi; 856 } 857 memcpy(dev->rd_msg_fifo + dev->rd_msg_fifo_tail, ishtp_msg, 858 ishtp_hdr->length); 859 dev->rd_msg_fifo_tail = (dev->rd_msg_fifo_tail + IPC_PAYLOAD_SIZE) % 860 (RD_INT_FIFO_SIZE * IPC_PAYLOAD_SIZE); 861 spin_unlock_irqrestore(&dev->rd_msg_spinlock, flags); 862 schedule_work(&dev->bh_hbm_work); 863 eoi: 864 return; 865 } 866 867 /** 868 * recv_fixed_cl_msg() - Receive fixed client message 869 * @dev: ISHTP device instance 870 * @ishtp_hdr: received bus message 871 * 872 * Receive and process ISHTP fixed client messages (address == 0) 873 * in ISR context 874 */ 875 void recv_fixed_cl_msg(struct ishtp_device *dev, 876 struct ishtp_msg_hdr *ishtp_hdr) 877 { 878 uint8_t rd_msg_buf[ISHTP_RD_MSG_BUF_SIZE]; 879 880 dev->print_log(dev, 881 "%s() got fixed client msg from client #%d\n", 882 __func__, ishtp_hdr->fw_addr); 883 dev->ops->ishtp_read(dev, rd_msg_buf, ishtp_hdr->length); 884 if (ishtp_hdr->fw_addr == ISHTP_SYSTEM_STATE_CLIENT_ADDR) { 885 struct ish_system_states_header *msg_hdr = 886 (struct ish_system_states_header *)rd_msg_buf; 887 if (msg_hdr->cmd == SYSTEM_STATE_SUBSCRIBE) 888 ishtp_send_resume(dev); 889 /* if FW request arrived here, the system is not suspended */ 890 else 891 dev_err(dev->devc, "unknown fixed client msg [%02X]\n", 892 msg_hdr->cmd); 893 } 894 } 895 896 /** 897 * fix_cl_hdr() - Initialize fixed client header 898 * @hdr: message header 899 * @length: length of message 900 * @cl_addr: Client address 901 * 902 * Initialize message header for fixed client 903 */ 904 static inline void fix_cl_hdr(struct ishtp_msg_hdr *hdr, size_t length, 905 uint8_t cl_addr) 906 { 907 hdr->host_addr = 0; 908 hdr->fw_addr = cl_addr; 909 hdr->length = length; 910 hdr->msg_complete = 1; 911 hdr->reserved = 0; 912 } 913 914 /*** Suspend and resume notification ***/ 915 916 static uint32_t current_state; 917 static uint32_t supported_states = 0 | SUSPEND_STATE_BIT; 918 919 /** 920 * ishtp_send_suspend() - Send suspend message to FW 921 * @dev: ISHTP device instance 922 * 923 * Send suspend message to FW. This is useful for system freeze (non S3) case 924 */ 925 void ishtp_send_suspend(struct ishtp_device *dev) 926 { 927 struct ishtp_msg_hdr ishtp_hdr; 928 struct ish_system_states_status state_status_msg; 929 const size_t len = sizeof(struct ish_system_states_status); 930 931 fix_cl_hdr(&ishtp_hdr, len, ISHTP_SYSTEM_STATE_CLIENT_ADDR); 932 933 memset(&state_status_msg, 0, len); 934 state_status_msg.hdr.cmd = SYSTEM_STATE_STATUS; 935 state_status_msg.supported_states = supported_states; 936 current_state |= SUSPEND_STATE_BIT; 937 dev->print_log(dev, "%s() sends SUSPEND notification\n", __func__); 938 state_status_msg.states_status = current_state; 939 940 ishtp_write_message(dev, &ishtp_hdr, 941 (unsigned char *)&state_status_msg); 942 } 943 EXPORT_SYMBOL(ishtp_send_suspend); 944 945 /** 946 * ishtp_send_resume() - Send resume message to FW 947 * @dev: ISHTP device instance 948 * 949 * Send resume message to FW. This is useful for system freeze (non S3) case 950 */ 951 void ishtp_send_resume(struct ishtp_device *dev) 952 { 953 struct ishtp_msg_hdr ishtp_hdr; 954 struct ish_system_states_status state_status_msg; 955 const size_t len = sizeof(struct ish_system_states_status); 956 957 fix_cl_hdr(&ishtp_hdr, len, ISHTP_SYSTEM_STATE_CLIENT_ADDR); 958 959 memset(&state_status_msg, 0, len); 960 state_status_msg.hdr.cmd = SYSTEM_STATE_STATUS; 961 state_status_msg.supported_states = supported_states; 962 current_state &= ~SUSPEND_STATE_BIT; 963 dev->print_log(dev, "%s() sends RESUME notification\n", __func__); 964 state_status_msg.states_status = current_state; 965 966 ishtp_write_message(dev, &ishtp_hdr, 967 (unsigned char *)&state_status_msg); 968 } 969 EXPORT_SYMBOL(ishtp_send_resume); 970 971 /** 972 * ishtp_query_subscribers() - Send query subscribers message 973 * @dev: ISHTP device instance 974 * 975 * Send message to query subscribers 976 */ 977 void ishtp_query_subscribers(struct ishtp_device *dev) 978 { 979 struct ishtp_msg_hdr ishtp_hdr; 980 struct ish_system_states_query_subscribers query_subscribers_msg; 981 const size_t len = sizeof(struct ish_system_states_query_subscribers); 982 983 fix_cl_hdr(&ishtp_hdr, len, ISHTP_SYSTEM_STATE_CLIENT_ADDR); 984 985 memset(&query_subscribers_msg, 0, len); 986 query_subscribers_msg.hdr.cmd = SYSTEM_STATE_QUERY_SUBSCRIBERS; 987 988 ishtp_write_message(dev, &ishtp_hdr, 989 (unsigned char *)&query_subscribers_msg); 990 } 991