Loading...
Note: File does not exist in v3.1.
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright (c) 2003-2022, Intel Corporation. All rights reserved.
4 * Intel Management Engine Interface (Intel MEI) Linux driver
5 */
6#include <linux/export.h>
7#include <linux/sched.h>
8#include <linux/wait.h>
9#include <linux/pm_runtime.h>
10#include <linux/slab.h>
11
12#include <linux/mei.h>
13
14#include "mei_dev.h"
15#include "hbm.h"
16#include "client.h"
17
18static const char *mei_hbm_status_str(enum mei_hbm_status status)
19{
20#define MEI_HBM_STATUS(status) case MEI_HBMS_##status: return #status
21 switch (status) {
22 MEI_HBM_STATUS(SUCCESS);
23 MEI_HBM_STATUS(CLIENT_NOT_FOUND);
24 MEI_HBM_STATUS(ALREADY_EXISTS);
25 MEI_HBM_STATUS(REJECTED);
26 MEI_HBM_STATUS(INVALID_PARAMETER);
27 MEI_HBM_STATUS(NOT_ALLOWED);
28 MEI_HBM_STATUS(ALREADY_STARTED);
29 MEI_HBM_STATUS(NOT_STARTED);
30 default: return "unknown";
31 }
32#undef MEI_HBM_STATUS
33};
34
35static const char *mei_cl_conn_status_str(enum mei_cl_connect_status status)
36{
37#define MEI_CL_CS(status) case MEI_CL_CONN_##status: return #status
38 switch (status) {
39 MEI_CL_CS(SUCCESS);
40 MEI_CL_CS(NOT_FOUND);
41 MEI_CL_CS(ALREADY_STARTED);
42 MEI_CL_CS(OUT_OF_RESOURCES);
43 MEI_CL_CS(MESSAGE_SMALL);
44 MEI_CL_CS(NOT_ALLOWED);
45 default: return "unknown";
46 }
47#undef MEI_CL_CCS
48}
49
50const char *mei_hbm_state_str(enum mei_hbm_state state)
51{
52#define MEI_HBM_STATE(state) case MEI_HBM_##state: return #state
53 switch (state) {
54 MEI_HBM_STATE(IDLE);
55 MEI_HBM_STATE(STARTING);
56 MEI_HBM_STATE(STARTED);
57 MEI_HBM_STATE(DR_SETUP);
58 MEI_HBM_STATE(ENUM_CLIENTS);
59 MEI_HBM_STATE(CLIENT_PROPERTIES);
60 MEI_HBM_STATE(STOPPED);
61 default:
62 return "unknown";
63 }
64#undef MEI_HBM_STATE
65}
66
67/**
68 * mei_cl_conn_status_to_errno - convert client connect response
69 * status to error code
70 *
71 * @status: client connect response status
72 *
73 * Return: corresponding error code
74 */
75static int mei_cl_conn_status_to_errno(enum mei_cl_connect_status status)
76{
77 switch (status) {
78 case MEI_CL_CONN_SUCCESS: return 0;
79 case MEI_CL_CONN_NOT_FOUND: return -ENOTTY;
80 case MEI_CL_CONN_ALREADY_STARTED: return -EBUSY;
81 case MEI_CL_CONN_OUT_OF_RESOURCES: return -EBUSY;
82 case MEI_CL_CONN_MESSAGE_SMALL: return -EINVAL;
83 case MEI_CL_CONN_NOT_ALLOWED: return -EBUSY;
84 default: return -EINVAL;
85 }
86}
87
88/**
89 * mei_hbm_write_message - wrapper for sending hbm messages.
90 *
91 * @dev: mei device
92 * @hdr: mei header
93 * @data: payload
94 */
95static inline int mei_hbm_write_message(struct mei_device *dev,
96 struct mei_msg_hdr *hdr,
97 const void *data)
98{
99 return mei_write_message(dev, hdr, sizeof(*hdr), data, hdr->length);
100}
101
102/**
103 * mei_hbm_idle - set hbm to idle state
104 *
105 * @dev: the device structure
106 */
107void mei_hbm_idle(struct mei_device *dev)
108{
109 dev->init_clients_timer = 0;
110 dev->hbm_state = MEI_HBM_IDLE;
111}
112
113/**
114 * mei_hbm_reset - reset hbm counters and book keeping data structurs
115 *
116 * @dev: the device structure
117 */
118void mei_hbm_reset(struct mei_device *dev)
119{
120 mei_me_cl_rm_all(dev);
121
122 mei_hbm_idle(dev);
123}
124
125/**
126 * mei_hbm_hdr - construct hbm header
127 *
128 * @mei_hdr: hbm header
129 * @length: payload length
130 */
131
132static inline void mei_hbm_hdr(struct mei_msg_hdr *mei_hdr, size_t length)
133{
134 memset(mei_hdr, 0, sizeof(*mei_hdr));
135 mei_hdr->length = length;
136 mei_hdr->msg_complete = 1;
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 */
147static inline
148void 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 * @buf: message buffer
166 * @len: buffer length
167 *
168 * Return: 0 on success, <0 on failure.
169 */
170static inline int mei_hbm_cl_write(struct mei_device *dev, struct mei_cl *cl,
171 u8 hbm_cmd, void *buf, size_t len)
172{
173 struct mei_msg_hdr mei_hdr;
174
175 mei_hbm_hdr(&mei_hdr, len);
176 mei_hbm_cl_hdr(cl, hbm_cmd, buf, len);
177
178 return mei_hbm_write_message(dev, &mei_hdr, buf);
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 */
190static inline
191bool 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 */
205static inline
206struct 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 */
225int 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 dev->timeouts.hbm);
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 */
253int mei_hbm_start_req(struct mei_device *dev)
254{
255 struct mei_msg_hdr mei_hdr;
256 struct hbm_host_version_request req;
257 int ret;
258
259 mei_hbm_reset(dev);
260
261 mei_hbm_hdr(&mei_hdr, sizeof(req));
262
263 /* host start message */
264 memset(&req, 0, sizeof(req));
265 req.hbm_cmd = HOST_START_REQ_CMD;
266 req.host_version.major_version = HBM_MAJOR_VERSION;
267 req.host_version.minor_version = HBM_MINOR_VERSION;
268
269 dev->hbm_state = MEI_HBM_IDLE;
270 ret = mei_hbm_write_message(dev, &mei_hdr, &req);
271 if (ret) {
272 dev_err(dev->dev, "version message write failed: ret = %d\n",
273 ret);
274 return ret;
275 }
276
277 dev->hbm_state = MEI_HBM_STARTING;
278 dev->init_clients_timer = dev->timeouts.client_init;
279 mei_schedule_stall_timer(dev);
280 return 0;
281}
282
283/**
284 * mei_hbm_dma_setup_req() - setup DMA request
285 * @dev: the device structure
286 *
287 * Return: 0 on success and < 0 on failure
288 */
289static int mei_hbm_dma_setup_req(struct mei_device *dev)
290{
291 struct mei_msg_hdr mei_hdr;
292 struct hbm_dma_setup_request req;
293 unsigned int i;
294 int ret;
295
296 mei_hbm_hdr(&mei_hdr, sizeof(req));
297
298 memset(&req, 0, sizeof(req));
299 req.hbm_cmd = MEI_HBM_DMA_SETUP_REQ_CMD;
300 for (i = 0; i < DMA_DSCR_NUM; i++) {
301 phys_addr_t paddr;
302
303 paddr = dev->dr_dscr[i].daddr;
304 req.dma_dscr[i].addr_hi = upper_32_bits(paddr);
305 req.dma_dscr[i].addr_lo = lower_32_bits(paddr);
306 req.dma_dscr[i].size = dev->dr_dscr[i].size;
307 }
308
309 mei_dma_ring_reset(dev);
310
311 ret = mei_hbm_write_message(dev, &mei_hdr, &req);
312 if (ret) {
313 dev_err(dev->dev, "dma setup request write failed: ret = %d.\n",
314 ret);
315 return ret;
316 }
317
318 dev->hbm_state = MEI_HBM_DR_SETUP;
319 dev->init_clients_timer = dev->timeouts.client_init;
320 mei_schedule_stall_timer(dev);
321 return 0;
322}
323
324/**
325 * mei_hbm_capabilities_req - request capabilities
326 *
327 * @dev: the device structure
328 *
329 * Return: 0 on success and < 0 on failure
330 */
331static int mei_hbm_capabilities_req(struct mei_device *dev)
332{
333 struct mei_msg_hdr mei_hdr;
334 struct hbm_capability_request req;
335 int ret;
336
337 mei_hbm_hdr(&mei_hdr, sizeof(req));
338
339 memset(&req, 0, sizeof(req));
340 req.hbm_cmd = MEI_HBM_CAPABILITIES_REQ_CMD;
341 if (dev->hbm_f_vt_supported)
342 req.capability_requested[0] |= HBM_CAP_VT;
343
344 if (dev->hbm_f_cd_supported)
345 req.capability_requested[0] |= HBM_CAP_CD;
346
347 if (dev->hbm_f_gsc_supported)
348 req.capability_requested[0] |= HBM_CAP_GSC;
349
350 ret = mei_hbm_write_message(dev, &mei_hdr, &req);
351 if (ret) {
352 dev_err(dev->dev,
353 "capabilities request write failed: ret = %d.\n", ret);
354 return ret;
355 }
356
357 dev->hbm_state = MEI_HBM_CAP_SETUP;
358 dev->init_clients_timer = dev->timeouts.client_init;
359 mei_schedule_stall_timer(dev);
360 return 0;
361}
362
363/**
364 * mei_hbm_enum_clients_req - sends enumeration client request message.
365 *
366 * @dev: the device structure
367 *
368 * Return: 0 on success and < 0 on failure
369 */
370static int mei_hbm_enum_clients_req(struct mei_device *dev)
371{
372 struct mei_msg_hdr mei_hdr;
373 struct hbm_host_enum_request req;
374 int ret;
375
376 /* enumerate clients */
377 mei_hbm_hdr(&mei_hdr, sizeof(req));
378
379 memset(&req, 0, sizeof(req));
380 req.hbm_cmd = HOST_ENUM_REQ_CMD;
381 req.flags |= dev->hbm_f_dc_supported ? MEI_HBM_ENUM_F_ALLOW_ADD : 0;
382 req.flags |= dev->hbm_f_ie_supported ?
383 MEI_HBM_ENUM_F_IMMEDIATE_ENUM : 0;
384
385 ret = mei_hbm_write_message(dev, &mei_hdr, &req);
386 if (ret) {
387 dev_err(dev->dev, "enumeration request write failed: ret = %d.\n",
388 ret);
389 return ret;
390 }
391 dev->hbm_state = MEI_HBM_ENUM_CLIENTS;
392 dev->init_clients_timer = dev->timeouts.client_init;
393 mei_schedule_stall_timer(dev);
394 return 0;
395}
396
397/**
398 * mei_hbm_me_cl_add - add new me client to the list
399 *
400 * @dev: the device structure
401 * @res: hbm property response
402 *
403 * Return: 0 on success and -ENOMEM on allocation failure
404 */
405
406static int mei_hbm_me_cl_add(struct mei_device *dev,
407 struct hbm_props_response *res)
408{
409 struct mei_me_client *me_cl;
410 const uuid_le *uuid = &res->client_properties.protocol_name;
411
412 mei_me_cl_rm_by_uuid(dev, uuid);
413
414 me_cl = kzalloc(sizeof(*me_cl), GFP_KERNEL);
415 if (!me_cl)
416 return -ENOMEM;
417
418 mei_me_cl_init(me_cl);
419
420 me_cl->props = res->client_properties;
421 me_cl->client_id = res->me_addr;
422 me_cl->tx_flow_ctrl_creds = 0;
423
424 mei_me_cl_add(dev, me_cl);
425
426 return 0;
427}
428
429/**
430 * mei_hbm_add_cl_resp - send response to fw on client add request
431 *
432 * @dev: the device structure
433 * @addr: me address
434 * @status: response status
435 *
436 * Return: 0 on success and < 0 on failure
437 */
438static int mei_hbm_add_cl_resp(struct mei_device *dev, u8 addr, u8 status)
439{
440 struct mei_msg_hdr mei_hdr;
441 struct hbm_add_client_response resp;
442 int ret;
443
444 dev_dbg(dev->dev, "adding client response\n");
445
446 mei_hbm_hdr(&mei_hdr, sizeof(resp));
447
448 memset(&resp, 0, sizeof(resp));
449 resp.hbm_cmd = MEI_HBM_ADD_CLIENT_RES_CMD;
450 resp.me_addr = addr;
451 resp.status = status;
452
453 ret = mei_hbm_write_message(dev, &mei_hdr, &resp);
454 if (ret)
455 dev_err(dev->dev, "add client response write failed: ret = %d\n",
456 ret);
457 return ret;
458}
459
460/**
461 * mei_hbm_fw_add_cl_req - request from the fw to add a client
462 *
463 * @dev: the device structure
464 * @req: add client request
465 *
466 * Return: 0 on success and < 0 on failure
467 */
468static int mei_hbm_fw_add_cl_req(struct mei_device *dev,
469 struct hbm_add_client_request *req)
470{
471 int ret;
472 u8 status = MEI_HBMS_SUCCESS;
473
474 BUILD_BUG_ON(sizeof(struct hbm_add_client_request) !=
475 sizeof(struct hbm_props_response));
476
477 ret = mei_hbm_me_cl_add(dev, (struct hbm_props_response *)req);
478 if (ret)
479 status = !MEI_HBMS_SUCCESS;
480
481 if (dev->dev_state == MEI_DEV_ENABLED)
482 schedule_work(&dev->bus_rescan_work);
483
484 return mei_hbm_add_cl_resp(dev, req->me_addr, status);
485}
486
487/**
488 * mei_hbm_cl_notify_req - send notification request
489 *
490 * @dev: the device structure
491 * @cl: a client to disconnect from
492 * @start: true for start false for stop
493 *
494 * Return: 0 on success and -EIO on write failure
495 */
496int mei_hbm_cl_notify_req(struct mei_device *dev,
497 struct mei_cl *cl, u8 start)
498{
499
500 struct mei_msg_hdr mei_hdr;
501 struct hbm_notification_request req;
502 int ret;
503
504 mei_hbm_hdr(&mei_hdr, sizeof(req));
505 mei_hbm_cl_hdr(cl, MEI_HBM_NOTIFY_REQ_CMD, &req, sizeof(req));
506
507 req.start = start;
508
509 ret = mei_hbm_write_message(dev, &mei_hdr, &req);
510 if (ret)
511 dev_err(dev->dev, "notify request failed: ret = %d\n", ret);
512
513 return ret;
514}
515
516/**
517 * notify_res_to_fop - convert notification response to the proper
518 * notification FOP
519 *
520 * @cmd: client notification start response command
521 *
522 * Return: MEI_FOP_NOTIFY_START or MEI_FOP_NOTIFY_STOP;
523 */
524static inline enum mei_cb_file_ops notify_res_to_fop(struct mei_hbm_cl_cmd *cmd)
525{
526 struct hbm_notification_response *rs =
527 (struct hbm_notification_response *)cmd;
528
529 return mei_cl_notify_req2fop(rs->start);
530}
531
532/**
533 * mei_hbm_cl_notify_start_res - update the client state according
534 * notify start response
535 *
536 * @dev: the device structure
537 * @cl: mei host client
538 * @cmd: client notification start response command
539 */
540static void mei_hbm_cl_notify_start_res(struct mei_device *dev,
541 struct mei_cl *cl,
542 struct mei_hbm_cl_cmd *cmd)
543{
544 struct hbm_notification_response *rs =
545 (struct hbm_notification_response *)cmd;
546
547 cl_dbg(dev, cl, "hbm: notify start response status=%d\n", rs->status);
548
549 if (rs->status == MEI_HBMS_SUCCESS ||
550 rs->status == MEI_HBMS_ALREADY_STARTED) {
551 cl->notify_en = true;
552 cl->status = 0;
553 } else {
554 cl->status = -EINVAL;
555 }
556}
557
558/**
559 * mei_hbm_cl_notify_stop_res - update the client state according
560 * notify stop response
561 *
562 * @dev: the device structure
563 * @cl: mei host client
564 * @cmd: client notification stop response command
565 */
566static void mei_hbm_cl_notify_stop_res(struct mei_device *dev,
567 struct mei_cl *cl,
568 struct mei_hbm_cl_cmd *cmd)
569{
570 struct hbm_notification_response *rs =
571 (struct hbm_notification_response *)cmd;
572
573 cl_dbg(dev, cl, "hbm: notify stop response status=%d\n", rs->status);
574
575 if (rs->status == MEI_HBMS_SUCCESS ||
576 rs->status == MEI_HBMS_NOT_STARTED) {
577 cl->notify_en = false;
578 cl->status = 0;
579 } else {
580 /* TODO: spec is not clear yet about other possible issues */
581 cl->status = -EINVAL;
582 }
583}
584
585/**
586 * mei_hbm_cl_notify - signal notification event
587 *
588 * @dev: the device structure
589 * @cmd: notification client message
590 */
591static void mei_hbm_cl_notify(struct mei_device *dev,
592 struct mei_hbm_cl_cmd *cmd)
593{
594 struct mei_cl *cl;
595
596 cl = mei_hbm_cl_find_by_cmd(dev, cmd);
597 if (cl)
598 mei_cl_notify(cl);
599}
600
601/**
602 * mei_hbm_cl_dma_map_req - send client dma map request
603 *
604 * @dev: the device structure
605 * @cl: mei host client
606 *
607 * Return: 0 on success and -EIO on write failure
608 */
609int mei_hbm_cl_dma_map_req(struct mei_device *dev, struct mei_cl *cl)
610{
611 struct mei_msg_hdr mei_hdr;
612 struct hbm_client_dma_map_request req;
613 int ret;
614
615 mei_hbm_hdr(&mei_hdr, sizeof(req));
616
617 memset(&req, 0, sizeof(req));
618
619 req.hbm_cmd = MEI_HBM_CLIENT_DMA_MAP_REQ_CMD;
620 req.client_buffer_id = cl->dma.buffer_id;
621 req.address_lsb = lower_32_bits(cl->dma.daddr);
622 req.address_msb = upper_32_bits(cl->dma.daddr);
623 req.size = cl->dma.size;
624
625 ret = mei_hbm_write_message(dev, &mei_hdr, &req);
626 if (ret)
627 dev_err(dev->dev, "dma map request failed: ret = %d\n", ret);
628
629 return ret;
630}
631
632/**
633 * mei_hbm_cl_dma_unmap_req - send client dma unmap request
634 *
635 * @dev: the device structure
636 * @cl: mei host client
637 *
638 * Return: 0 on success and -EIO on write failure
639 */
640int mei_hbm_cl_dma_unmap_req(struct mei_device *dev, struct mei_cl *cl)
641{
642 struct mei_msg_hdr mei_hdr;
643 struct hbm_client_dma_unmap_request req;
644 int ret;
645
646 mei_hbm_hdr(&mei_hdr, sizeof(req));
647
648 memset(&req, 0, sizeof(req));
649
650 req.hbm_cmd = MEI_HBM_CLIENT_DMA_UNMAP_REQ_CMD;
651 req.client_buffer_id = cl->dma.buffer_id;
652
653 ret = mei_hbm_write_message(dev, &mei_hdr, &req);
654 if (ret)
655 dev_err(dev->dev, "dma unmap request failed: ret = %d\n", ret);
656
657 return ret;
658}
659
660static void mei_hbm_cl_dma_map_res(struct mei_device *dev,
661 struct hbm_client_dma_response *res)
662{
663 struct mei_cl *cl;
664 struct mei_cl_cb *cb, *next;
665
666 cl = NULL;
667 list_for_each_entry_safe(cb, next, &dev->ctrl_rd_list, list) {
668 if (cb->fop_type != MEI_FOP_DMA_MAP)
669 continue;
670 if (!cb->cl->dma.buffer_id || cb->cl->dma_mapped)
671 continue;
672
673 cl = cb->cl;
674 break;
675 }
676 if (!cl)
677 return;
678
679 if (res->status) {
680 dev_err(dev->dev, "cl dma map failed %d\n", res->status);
681 cl->status = -EFAULT;
682 } else {
683 dev_dbg(dev->dev, "cl dma map succeeded\n");
684 cl->dma_mapped = 1;
685 cl->status = 0;
686 }
687 wake_up(&cl->wait);
688}
689
690static void mei_hbm_cl_dma_unmap_res(struct mei_device *dev,
691 struct hbm_client_dma_response *res)
692{
693 struct mei_cl *cl;
694 struct mei_cl_cb *cb, *next;
695
696 cl = NULL;
697 list_for_each_entry_safe(cb, next, &dev->ctrl_rd_list, list) {
698 if (cb->fop_type != MEI_FOP_DMA_UNMAP)
699 continue;
700 if (!cb->cl->dma.buffer_id || !cb->cl->dma_mapped)
701 continue;
702
703 cl = cb->cl;
704 break;
705 }
706 if (!cl)
707 return;
708
709 if (res->status) {
710 dev_err(dev->dev, "cl dma unmap failed %d\n", res->status);
711 cl->status = -EFAULT;
712 } else {
713 dev_dbg(dev->dev, "cl dma unmap succeeded\n");
714 cl->dma_mapped = 0;
715 cl->status = 0;
716 }
717 wake_up(&cl->wait);
718}
719
720/**
721 * mei_hbm_prop_req - request property for a single client
722 *
723 * @dev: the device structure
724 * @start_idx: client index to start search
725 *
726 * Return: 0 on success and < 0 on failure
727 */
728static int mei_hbm_prop_req(struct mei_device *dev, unsigned long start_idx)
729{
730 struct mei_msg_hdr mei_hdr;
731 struct hbm_props_request req;
732 unsigned long addr;
733 int ret;
734
735 addr = find_next_bit(dev->me_clients_map, MEI_CLIENTS_MAX, start_idx);
736
737 /* We got all client properties */
738 if (addr == MEI_CLIENTS_MAX) {
739 dev->hbm_state = MEI_HBM_STARTED;
740 mei_host_client_init(dev);
741 return 0;
742 }
743
744 mei_hbm_hdr(&mei_hdr, sizeof(req));
745
746 memset(&req, 0, sizeof(req));
747
748 req.hbm_cmd = HOST_CLIENT_PROPERTIES_REQ_CMD;
749 req.me_addr = addr;
750
751 ret = mei_hbm_write_message(dev, &mei_hdr, &req);
752 if (ret) {
753 dev_err(dev->dev, "properties request write failed: ret = %d\n",
754 ret);
755 return ret;
756 }
757
758 dev->init_clients_timer = dev->timeouts.client_init;
759 mei_schedule_stall_timer(dev);
760
761 return 0;
762}
763
764/**
765 * mei_hbm_pg - sends pg command
766 *
767 * @dev: the device structure
768 * @pg_cmd: the pg command code
769 *
770 * Return: -EIO on write failure
771 * -EOPNOTSUPP if the operation is not supported by the protocol
772 */
773int mei_hbm_pg(struct mei_device *dev, u8 pg_cmd)
774{
775 struct mei_msg_hdr mei_hdr;
776 struct hbm_power_gate req;
777 int ret;
778
779 if (!dev->hbm_f_pg_supported)
780 return -EOPNOTSUPP;
781
782 mei_hbm_hdr(&mei_hdr, sizeof(req));
783
784 memset(&req, 0, sizeof(req));
785 req.hbm_cmd = pg_cmd;
786
787 ret = mei_hbm_write_message(dev, &mei_hdr, &req);
788 if (ret)
789 dev_err(dev->dev, "power gate command write failed.\n");
790 return ret;
791}
792EXPORT_SYMBOL_GPL(mei_hbm_pg);
793
794/**
795 * mei_hbm_stop_req - send stop request message
796 *
797 * @dev: mei device
798 *
799 * Return: -EIO on write failure
800 */
801static int mei_hbm_stop_req(struct mei_device *dev)
802{
803 struct mei_msg_hdr mei_hdr;
804 struct hbm_host_stop_request req;
805
806 mei_hbm_hdr(&mei_hdr, sizeof(req));
807
808 memset(&req, 0, sizeof(req));
809 req.hbm_cmd = HOST_STOP_REQ_CMD;
810 req.reason = DRIVER_STOP_REQUEST;
811
812 return mei_hbm_write_message(dev, &mei_hdr, &req);
813}
814
815/**
816 * mei_hbm_cl_flow_control_req - sends flow control request.
817 *
818 * @dev: the device structure
819 * @cl: client info
820 *
821 * Return: -EIO on write failure
822 */
823int mei_hbm_cl_flow_control_req(struct mei_device *dev, struct mei_cl *cl)
824{
825 struct hbm_flow_control req;
826
827 cl_dbg(dev, cl, "sending flow control\n");
828 return mei_hbm_cl_write(dev, cl, MEI_FLOW_CONTROL_CMD,
829 &req, sizeof(req));
830}
831
832/**
833 * mei_hbm_add_single_tx_flow_ctrl_creds - adds single buffer credentials.
834 *
835 * @dev: the device structure
836 * @fctrl: flow control response bus message
837 *
838 * Return: 0 on success, < 0 otherwise
839 */
840static int mei_hbm_add_single_tx_flow_ctrl_creds(struct mei_device *dev,
841 struct hbm_flow_control *fctrl)
842{
843 struct mei_me_client *me_cl;
844 int rets;
845
846 me_cl = mei_me_cl_by_id(dev, fctrl->me_addr);
847 if (!me_cl) {
848 dev_err(dev->dev, "no such me client %d\n", fctrl->me_addr);
849 return -ENOENT;
850 }
851
852 if (WARN_ON(me_cl->props.single_recv_buf == 0)) {
853 rets = -EINVAL;
854 goto out;
855 }
856
857 me_cl->tx_flow_ctrl_creds++;
858 dev_dbg(dev->dev, "recv flow ctrl msg ME %d (single) creds = %d.\n",
859 fctrl->me_addr, me_cl->tx_flow_ctrl_creds);
860
861 rets = 0;
862out:
863 mei_me_cl_put(me_cl);
864 return rets;
865}
866
867/**
868 * mei_hbm_cl_tx_flow_ctrl_creds_res - flow control response from me
869 *
870 * @dev: the device structure
871 * @fctrl: flow control response bus message
872 */
873static void mei_hbm_cl_tx_flow_ctrl_creds_res(struct mei_device *dev,
874 struct hbm_flow_control *fctrl)
875{
876 struct mei_cl *cl;
877
878 if (!fctrl->host_addr) {
879 /* single receive buffer */
880 mei_hbm_add_single_tx_flow_ctrl_creds(dev, fctrl);
881 return;
882 }
883
884 cl = mei_hbm_cl_find_by_cmd(dev, fctrl);
885 if (cl) {
886 cl->tx_flow_ctrl_creds++;
887 cl_dbg(dev, cl, "flow control creds = %d.\n",
888 cl->tx_flow_ctrl_creds);
889 }
890}
891
892
893/**
894 * mei_hbm_cl_disconnect_req - sends disconnect message to fw.
895 *
896 * @dev: the device structure
897 * @cl: a client to disconnect from
898 *
899 * Return: -EIO on write failure
900 */
901int mei_hbm_cl_disconnect_req(struct mei_device *dev, struct mei_cl *cl)
902{
903 struct hbm_client_connect_request req;
904
905 return mei_hbm_cl_write(dev, cl, CLIENT_DISCONNECT_REQ_CMD,
906 &req, sizeof(req));
907}
908
909/**
910 * mei_hbm_cl_disconnect_rsp - sends disconnect respose to the FW
911 *
912 * @dev: the device structure
913 * @cl: a client to disconnect from
914 *
915 * Return: -EIO on write failure
916 */
917int mei_hbm_cl_disconnect_rsp(struct mei_device *dev, struct mei_cl *cl)
918{
919 struct hbm_client_connect_response resp;
920
921 return mei_hbm_cl_write(dev, cl, CLIENT_DISCONNECT_RES_CMD,
922 &resp, sizeof(resp));
923}
924
925/**
926 * mei_hbm_cl_disconnect_res - update the client state according
927 * disconnect response
928 *
929 * @dev: the device structure
930 * @cl: mei host client
931 * @cmd: disconnect client response host bus message
932 */
933static void mei_hbm_cl_disconnect_res(struct mei_device *dev, struct mei_cl *cl,
934 struct mei_hbm_cl_cmd *cmd)
935{
936 struct hbm_client_connect_response *rs =
937 (struct hbm_client_connect_response *)cmd;
938
939 cl_dbg(dev, cl, "hbm: disconnect response status=%d\n", rs->status);
940
941 if (rs->status == MEI_CL_DISCONN_SUCCESS)
942 cl->state = MEI_FILE_DISCONNECT_REPLY;
943 cl->status = 0;
944}
945
946/**
947 * mei_hbm_cl_connect_req - send connection request to specific me client
948 *
949 * @dev: the device structure
950 * @cl: a client to connect to
951 *
952 * Return: -EIO on write failure
953 */
954int mei_hbm_cl_connect_req(struct mei_device *dev, struct mei_cl *cl)
955{
956 struct hbm_client_connect_request req;
957
958 return mei_hbm_cl_write(dev, cl, CLIENT_CONNECT_REQ_CMD,
959 &req, sizeof(req));
960}
961
962/**
963 * mei_hbm_cl_connect_res - update the client state according
964 * connection response
965 *
966 * @dev: the device structure
967 * @cl: mei host client
968 * @cmd: connect client response host bus message
969 */
970static void mei_hbm_cl_connect_res(struct mei_device *dev, struct mei_cl *cl,
971 struct mei_hbm_cl_cmd *cmd)
972{
973 struct hbm_client_connect_response *rs =
974 (struct hbm_client_connect_response *)cmd;
975
976 cl_dbg(dev, cl, "hbm: connect response status=%s\n",
977 mei_cl_conn_status_str(rs->status));
978
979 if (rs->status == MEI_CL_CONN_SUCCESS)
980 cl->state = MEI_FILE_CONNECTED;
981 else {
982 cl->state = MEI_FILE_DISCONNECT_REPLY;
983 if (rs->status == MEI_CL_CONN_NOT_FOUND) {
984 mei_me_cl_del(dev, cl->me_cl);
985 if (dev->dev_state == MEI_DEV_ENABLED)
986 schedule_work(&dev->bus_rescan_work);
987 }
988 }
989 cl->status = mei_cl_conn_status_to_errno(rs->status);
990}
991
992/**
993 * mei_hbm_cl_res - process hbm response received on behalf
994 * an client
995 *
996 * @dev: the device structure
997 * @rs: hbm client message
998 * @fop_type: file operation type
999 */
1000static void mei_hbm_cl_res(struct mei_device *dev,
1001 struct mei_hbm_cl_cmd *rs,
1002 enum mei_cb_file_ops fop_type)
1003{
1004 struct mei_cl *cl;
1005 struct mei_cl_cb *cb, *next;
1006
1007 cl = NULL;
1008 list_for_each_entry_safe(cb, next, &dev->ctrl_rd_list, list) {
1009
1010 cl = cb->cl;
1011
1012 if (cb->fop_type != fop_type)
1013 continue;
1014
1015 if (mei_hbm_cl_addr_equal(cl, rs)) {
1016 list_del_init(&cb->list);
1017 break;
1018 }
1019 }
1020
1021 if (!cl)
1022 return;
1023
1024 switch (fop_type) {
1025 case MEI_FOP_CONNECT:
1026 mei_hbm_cl_connect_res(dev, cl, rs);
1027 break;
1028 case MEI_FOP_DISCONNECT:
1029 mei_hbm_cl_disconnect_res(dev, cl, rs);
1030 break;
1031 case MEI_FOP_NOTIFY_START:
1032 mei_hbm_cl_notify_start_res(dev, cl, rs);
1033 break;
1034 case MEI_FOP_NOTIFY_STOP:
1035 mei_hbm_cl_notify_stop_res(dev, cl, rs);
1036 break;
1037 default:
1038 return;
1039 }
1040
1041 cl->timer_count = 0;
1042 wake_up(&cl->wait);
1043}
1044
1045
1046/**
1047 * mei_hbm_fw_disconnect_req - disconnect request initiated by ME firmware
1048 * host sends disconnect response
1049 *
1050 * @dev: the device structure.
1051 * @disconnect_req: disconnect request bus message from the me
1052 *
1053 * Return: -ENOMEM on allocation failure
1054 */
1055static int mei_hbm_fw_disconnect_req(struct mei_device *dev,
1056 struct hbm_client_connect_request *disconnect_req)
1057{
1058 struct mei_cl *cl;
1059 struct mei_cl_cb *cb;
1060
1061 cl = mei_hbm_cl_find_by_cmd(dev, disconnect_req);
1062 if (cl) {
1063 cl_warn(dev, cl, "fw disconnect request received\n");
1064 cl->state = MEI_FILE_DISCONNECTING;
1065 cl->timer_count = 0;
1066
1067 cb = mei_cl_enqueue_ctrl_wr_cb(cl, 0, MEI_FOP_DISCONNECT_RSP,
1068 NULL);
1069 if (!cb)
1070 return -ENOMEM;
1071 }
1072 return 0;
1073}
1074
1075/**
1076 * mei_hbm_pg_enter_res - PG enter response received
1077 *
1078 * @dev: the device structure.
1079 *
1080 * Return: 0 on success, -EPROTO on state mismatch
1081 */
1082static int mei_hbm_pg_enter_res(struct mei_device *dev)
1083{
1084 if (mei_pg_state(dev) != MEI_PG_OFF ||
1085 dev->pg_event != MEI_PG_EVENT_WAIT) {
1086 dev_err(dev->dev, "hbm: pg entry response: state mismatch [%s, %d]\n",
1087 mei_pg_state_str(mei_pg_state(dev)), dev->pg_event);
1088 return -EPROTO;
1089 }
1090
1091 dev->pg_event = MEI_PG_EVENT_RECEIVED;
1092 wake_up(&dev->wait_pg);
1093
1094 return 0;
1095}
1096
1097/**
1098 * mei_hbm_pg_resume - process with PG resume
1099 *
1100 * @dev: the device structure.
1101 */
1102void mei_hbm_pg_resume(struct mei_device *dev)
1103{
1104 pm_request_resume(dev->dev);
1105}
1106EXPORT_SYMBOL_GPL(mei_hbm_pg_resume);
1107
1108/**
1109 * mei_hbm_pg_exit_res - PG exit response received
1110 *
1111 * @dev: the device structure.
1112 *
1113 * Return: 0 on success, -EPROTO on state mismatch
1114 */
1115static int mei_hbm_pg_exit_res(struct mei_device *dev)
1116{
1117 if (mei_pg_state(dev) != MEI_PG_ON ||
1118 (dev->pg_event != MEI_PG_EVENT_WAIT &&
1119 dev->pg_event != MEI_PG_EVENT_IDLE)) {
1120 dev_err(dev->dev, "hbm: pg exit response: state mismatch [%s, %d]\n",
1121 mei_pg_state_str(mei_pg_state(dev)), dev->pg_event);
1122 return -EPROTO;
1123 }
1124
1125 switch (dev->pg_event) {
1126 case MEI_PG_EVENT_WAIT:
1127 dev->pg_event = MEI_PG_EVENT_RECEIVED;
1128 wake_up(&dev->wait_pg);
1129 break;
1130 case MEI_PG_EVENT_IDLE:
1131 /*
1132 * If the driver is not waiting on this then
1133 * this is HW initiated exit from PG.
1134 * Start runtime pm resume sequence to exit from PG.
1135 */
1136 dev->pg_event = MEI_PG_EVENT_RECEIVED;
1137 mei_hbm_pg_resume(dev);
1138 break;
1139 default:
1140 WARN(1, "hbm: pg exit response: unexpected pg event = %d\n",
1141 dev->pg_event);
1142 return -EPROTO;
1143 }
1144
1145 return 0;
1146}
1147
1148/**
1149 * mei_hbm_config_features - check what hbm features and commands
1150 * are supported by the fw
1151 *
1152 * @dev: the device structure
1153 */
1154static void mei_hbm_config_features(struct mei_device *dev)
1155{
1156 /* Power Gating Isolation Support */
1157 dev->hbm_f_pg_supported = 0;
1158 if (dev->version.major_version > HBM_MAJOR_VERSION_PGI)
1159 dev->hbm_f_pg_supported = 1;
1160
1161 if (dev->version.major_version == HBM_MAJOR_VERSION_PGI &&
1162 dev->version.minor_version >= HBM_MINOR_VERSION_PGI)
1163 dev->hbm_f_pg_supported = 1;
1164
1165 dev->hbm_f_dc_supported = 0;
1166 if (dev->version.major_version >= HBM_MAJOR_VERSION_DC)
1167 dev->hbm_f_dc_supported = 1;
1168
1169 dev->hbm_f_ie_supported = 0;
1170 if (dev->version.major_version >= HBM_MAJOR_VERSION_IE)
1171 dev->hbm_f_ie_supported = 1;
1172
1173 /* disconnect on connect timeout instead of link reset */
1174 dev->hbm_f_dot_supported = 0;
1175 if (dev->version.major_version >= HBM_MAJOR_VERSION_DOT)
1176 dev->hbm_f_dot_supported = 1;
1177
1178 /* Notification Event Support */
1179 dev->hbm_f_ev_supported = 0;
1180 if (dev->version.major_version >= HBM_MAJOR_VERSION_EV)
1181 dev->hbm_f_ev_supported = 1;
1182
1183 /* Fixed Address Client Support */
1184 dev->hbm_f_fa_supported = 0;
1185 if (dev->version.major_version >= HBM_MAJOR_VERSION_FA)
1186 dev->hbm_f_fa_supported = 1;
1187
1188 /* OS ver message Support */
1189 dev->hbm_f_os_supported = 0;
1190 if (dev->version.major_version >= HBM_MAJOR_VERSION_OS)
1191 dev->hbm_f_os_supported = 1;
1192
1193 /* DMA Ring Support */
1194 dev->hbm_f_dr_supported = 0;
1195 if (dev->version.major_version > HBM_MAJOR_VERSION_DR ||
1196 (dev->version.major_version == HBM_MAJOR_VERSION_DR &&
1197 dev->version.minor_version >= HBM_MINOR_VERSION_DR))
1198 dev->hbm_f_dr_supported = 1;
1199
1200 /* VTag Support */
1201 dev->hbm_f_vt_supported = 0;
1202 if (dev->version.major_version > HBM_MAJOR_VERSION_VT ||
1203 (dev->version.major_version == HBM_MAJOR_VERSION_VT &&
1204 dev->version.minor_version >= HBM_MINOR_VERSION_VT))
1205 dev->hbm_f_vt_supported = 1;
1206
1207 /* GSC support */
1208 if (dev->version.major_version > HBM_MAJOR_VERSION_GSC ||
1209 (dev->version.major_version == HBM_MAJOR_VERSION_GSC &&
1210 dev->version.minor_version >= HBM_MINOR_VERSION_GSC))
1211 dev->hbm_f_gsc_supported = 1;
1212
1213 /* Capability message Support */
1214 dev->hbm_f_cap_supported = 0;
1215 if (dev->version.major_version > HBM_MAJOR_VERSION_CAP ||
1216 (dev->version.major_version == HBM_MAJOR_VERSION_CAP &&
1217 dev->version.minor_version >= HBM_MINOR_VERSION_CAP))
1218 dev->hbm_f_cap_supported = 1;
1219
1220 /* Client DMA Support */
1221 dev->hbm_f_cd_supported = 0;
1222 if (dev->version.major_version > HBM_MAJOR_VERSION_CD ||
1223 (dev->version.major_version == HBM_MAJOR_VERSION_CD &&
1224 dev->version.minor_version >= HBM_MINOR_VERSION_CD))
1225 dev->hbm_f_cd_supported = 1;
1226}
1227
1228/**
1229 * mei_hbm_version_is_supported - checks whether the driver can
1230 * support the hbm version of the device
1231 *
1232 * @dev: the device structure
1233 * Return: true if driver can support hbm version of the device
1234 */
1235bool mei_hbm_version_is_supported(struct mei_device *dev)
1236{
1237 return (dev->version.major_version < HBM_MAJOR_VERSION) ||
1238 (dev->version.major_version == HBM_MAJOR_VERSION &&
1239 dev->version.minor_version <= HBM_MINOR_VERSION);
1240}
1241
1242/**
1243 * mei_hbm_dispatch - bottom half read routine after ISR to
1244 * handle the read bus message cmd processing.
1245 *
1246 * @dev: the device structure
1247 * @hdr: header of bus message
1248 *
1249 * Return: 0 on success and < 0 on failure
1250 */
1251int mei_hbm_dispatch(struct mei_device *dev, struct mei_msg_hdr *hdr)
1252{
1253 struct mei_bus_message *mei_msg;
1254 struct hbm_host_version_response *version_res;
1255 struct hbm_props_response *props_res;
1256 struct hbm_host_enum_response *enum_res;
1257 struct hbm_dma_setup_response *dma_setup_res;
1258 struct hbm_add_client_request *add_cl_req;
1259 struct hbm_capability_response *capability_res;
1260 int ret;
1261
1262 struct mei_hbm_cl_cmd *cl_cmd;
1263 struct hbm_client_connect_request *disconnect_req;
1264 struct hbm_flow_control *fctrl;
1265 struct hbm_client_dma_response *client_dma_res;
1266
1267 /* read the message to our buffer */
1268 BUG_ON(hdr->length >= sizeof(dev->rd_msg_buf));
1269 mei_read_slots(dev, dev->rd_msg_buf, hdr->length);
1270 mei_msg = (struct mei_bus_message *)dev->rd_msg_buf;
1271 cl_cmd = (struct mei_hbm_cl_cmd *)mei_msg;
1272
1273 /* ignore spurious message and prevent reset nesting
1274 * hbm is put to idle during system reset
1275 */
1276 if (dev->hbm_state == MEI_HBM_IDLE) {
1277 dev_dbg(dev->dev, "hbm: state is idle ignore spurious messages\n");
1278 return 0;
1279 }
1280
1281 switch (mei_msg->hbm_cmd) {
1282 case HOST_START_RES_CMD:
1283 dev_dbg(dev->dev, "hbm: start: response message received.\n");
1284
1285 dev->init_clients_timer = 0;
1286
1287 version_res = (struct hbm_host_version_response *)mei_msg;
1288
1289 dev_dbg(dev->dev, "HBM VERSION: DRIVER=%02d:%02d DEVICE=%02d:%02d\n",
1290 HBM_MAJOR_VERSION, HBM_MINOR_VERSION,
1291 version_res->me_max_version.major_version,
1292 version_res->me_max_version.minor_version);
1293
1294 if (version_res->host_version_supported) {
1295 dev->version.major_version = HBM_MAJOR_VERSION;
1296 dev->version.minor_version = HBM_MINOR_VERSION;
1297 } else {
1298 dev->version.major_version =
1299 version_res->me_max_version.major_version;
1300 dev->version.minor_version =
1301 version_res->me_max_version.minor_version;
1302 }
1303
1304 if (!mei_hbm_version_is_supported(dev)) {
1305 dev_warn(dev->dev, "hbm: start: version mismatch - stopping the driver.\n");
1306
1307 dev->hbm_state = MEI_HBM_STOPPED;
1308 if (mei_hbm_stop_req(dev)) {
1309 dev_err(dev->dev, "hbm: start: failed to send stop request\n");
1310 return -EIO;
1311 }
1312 break;
1313 }
1314
1315 mei_hbm_config_features(dev);
1316
1317 if (dev->dev_state != MEI_DEV_INIT_CLIENTS ||
1318 dev->hbm_state != MEI_HBM_STARTING) {
1319 if (dev->dev_state == MEI_DEV_POWER_DOWN ||
1320 dev->dev_state == MEI_DEV_POWERING_DOWN) {
1321 dev_dbg(dev->dev, "hbm: start: on shutdown, ignoring\n");
1322 return 0;
1323 }
1324 dev_err(dev->dev, "hbm: start: state mismatch, [%d, %d]\n",
1325 dev->dev_state, dev->hbm_state);
1326 return -EPROTO;
1327 }
1328
1329 if (dev->hbm_f_cap_supported) {
1330 if (mei_hbm_capabilities_req(dev))
1331 return -EIO;
1332 wake_up(&dev->wait_hbm_start);
1333 break;
1334 }
1335
1336 if (dev->hbm_f_dr_supported) {
1337 if (mei_dmam_ring_alloc(dev))
1338 dev_info(dev->dev, "running w/o dma ring\n");
1339 if (mei_dma_ring_is_allocated(dev)) {
1340 if (mei_hbm_dma_setup_req(dev))
1341 return -EIO;
1342
1343 wake_up(&dev->wait_hbm_start);
1344 break;
1345 }
1346 }
1347
1348 dev->hbm_f_dr_supported = 0;
1349 mei_dmam_ring_free(dev);
1350
1351 if (mei_hbm_enum_clients_req(dev))
1352 return -EIO;
1353
1354 wake_up(&dev->wait_hbm_start);
1355 break;
1356
1357 case MEI_HBM_CAPABILITIES_RES_CMD:
1358 dev_dbg(dev->dev, "hbm: capabilities response: message received.\n");
1359
1360 dev->init_clients_timer = 0;
1361
1362 if (dev->dev_state != MEI_DEV_INIT_CLIENTS ||
1363 dev->hbm_state != MEI_HBM_CAP_SETUP) {
1364 if (dev->dev_state == MEI_DEV_POWER_DOWN ||
1365 dev->dev_state == MEI_DEV_POWERING_DOWN) {
1366 dev_dbg(dev->dev, "hbm: capabilities response: on shutdown, ignoring\n");
1367 return 0;
1368 }
1369 dev_err(dev->dev, "hbm: capabilities response: state mismatch, [%d, %d]\n",
1370 dev->dev_state, dev->hbm_state);
1371 return -EPROTO;
1372 }
1373
1374 capability_res = (struct hbm_capability_response *)mei_msg;
1375 if (!(capability_res->capability_granted[0] & HBM_CAP_VT))
1376 dev->hbm_f_vt_supported = 0;
1377 if (!(capability_res->capability_granted[0] & HBM_CAP_CD))
1378 dev->hbm_f_cd_supported = 0;
1379
1380 if (!(capability_res->capability_granted[0] & HBM_CAP_GSC))
1381 dev->hbm_f_gsc_supported = 0;
1382
1383 if (dev->hbm_f_dr_supported) {
1384 if (mei_dmam_ring_alloc(dev))
1385 dev_info(dev->dev, "running w/o dma ring\n");
1386 if (mei_dma_ring_is_allocated(dev)) {
1387 if (mei_hbm_dma_setup_req(dev))
1388 return -EIO;
1389 break;
1390 }
1391 }
1392
1393 dev->hbm_f_dr_supported = 0;
1394 mei_dmam_ring_free(dev);
1395
1396 if (mei_hbm_enum_clients_req(dev))
1397 return -EIO;
1398 break;
1399
1400 case MEI_HBM_DMA_SETUP_RES_CMD:
1401 dev_dbg(dev->dev, "hbm: dma setup response: message received.\n");
1402
1403 dev->init_clients_timer = 0;
1404
1405 if (dev->dev_state != MEI_DEV_INIT_CLIENTS ||
1406 dev->hbm_state != MEI_HBM_DR_SETUP) {
1407 if (dev->dev_state == MEI_DEV_POWER_DOWN ||
1408 dev->dev_state == MEI_DEV_POWERING_DOWN) {
1409 dev_dbg(dev->dev, "hbm: dma setup response: on shutdown, ignoring\n");
1410 return 0;
1411 }
1412 dev_err(dev->dev, "hbm: dma setup response: state mismatch, [%d, %d]\n",
1413 dev->dev_state, dev->hbm_state);
1414 return -EPROTO;
1415 }
1416
1417 dma_setup_res = (struct hbm_dma_setup_response *)mei_msg;
1418
1419 if (dma_setup_res->status) {
1420 u8 status = dma_setup_res->status;
1421
1422 if (status == MEI_HBMS_NOT_ALLOWED) {
1423 dev_dbg(dev->dev, "hbm: dma setup not allowed\n");
1424 } else {
1425 dev_info(dev->dev, "hbm: dma setup response: failure = %d %s\n",
1426 status,
1427 mei_hbm_status_str(status));
1428 }
1429 dev->hbm_f_dr_supported = 0;
1430 mei_dmam_ring_free(dev);
1431 }
1432
1433 if (mei_hbm_enum_clients_req(dev))
1434 return -EIO;
1435 break;
1436
1437 case CLIENT_CONNECT_RES_CMD:
1438 dev_dbg(dev->dev, "hbm: client connect response: message received.\n");
1439 mei_hbm_cl_res(dev, cl_cmd, MEI_FOP_CONNECT);
1440 break;
1441
1442 case CLIENT_DISCONNECT_RES_CMD:
1443 dev_dbg(dev->dev, "hbm: client disconnect response: message received.\n");
1444 mei_hbm_cl_res(dev, cl_cmd, MEI_FOP_DISCONNECT);
1445 break;
1446
1447 case MEI_FLOW_CONTROL_CMD:
1448 dev_dbg(dev->dev, "hbm: client flow control response: message received.\n");
1449
1450 fctrl = (struct hbm_flow_control *)mei_msg;
1451 mei_hbm_cl_tx_flow_ctrl_creds_res(dev, fctrl);
1452 break;
1453
1454 case MEI_PG_ISOLATION_ENTRY_RES_CMD:
1455 dev_dbg(dev->dev, "hbm: power gate isolation entry response received\n");
1456 ret = mei_hbm_pg_enter_res(dev);
1457 if (ret)
1458 return ret;
1459 break;
1460
1461 case MEI_PG_ISOLATION_EXIT_REQ_CMD:
1462 dev_dbg(dev->dev, "hbm: power gate isolation exit request received\n");
1463 ret = mei_hbm_pg_exit_res(dev);
1464 if (ret)
1465 return ret;
1466 break;
1467
1468 case HOST_CLIENT_PROPERTIES_RES_CMD:
1469 dev_dbg(dev->dev, "hbm: properties response: message received.\n");
1470
1471 dev->init_clients_timer = 0;
1472
1473 if (dev->dev_state != MEI_DEV_INIT_CLIENTS ||
1474 dev->hbm_state != MEI_HBM_CLIENT_PROPERTIES) {
1475 if (dev->dev_state == MEI_DEV_POWER_DOWN ||
1476 dev->dev_state == MEI_DEV_POWERING_DOWN) {
1477 dev_dbg(dev->dev, "hbm: properties response: on shutdown, ignoring\n");
1478 return 0;
1479 }
1480 dev_err(dev->dev, "hbm: properties response: state mismatch, [%d, %d]\n",
1481 dev->dev_state, dev->hbm_state);
1482 return -EPROTO;
1483 }
1484
1485 props_res = (struct hbm_props_response *)mei_msg;
1486
1487 if (props_res->status == MEI_HBMS_CLIENT_NOT_FOUND) {
1488 dev_dbg(dev->dev, "hbm: properties response: %d CLIENT_NOT_FOUND\n",
1489 props_res->me_addr);
1490 } else if (props_res->status) {
1491 dev_err(dev->dev, "hbm: properties response: wrong status = %d %s\n",
1492 props_res->status,
1493 mei_hbm_status_str(props_res->status));
1494 return -EPROTO;
1495 } else {
1496 mei_hbm_me_cl_add(dev, props_res);
1497 }
1498
1499 /* request property for the next client */
1500 if (mei_hbm_prop_req(dev, props_res->me_addr + 1))
1501 return -EIO;
1502
1503 break;
1504
1505 case HOST_ENUM_RES_CMD:
1506 dev_dbg(dev->dev, "hbm: enumeration response: message received\n");
1507
1508 dev->init_clients_timer = 0;
1509
1510 enum_res = (struct hbm_host_enum_response *) mei_msg;
1511 BUILD_BUG_ON(sizeof(dev->me_clients_map)
1512 < sizeof(enum_res->valid_addresses));
1513 memcpy(dev->me_clients_map, enum_res->valid_addresses,
1514 sizeof(enum_res->valid_addresses));
1515
1516 if (dev->dev_state != MEI_DEV_INIT_CLIENTS ||
1517 dev->hbm_state != MEI_HBM_ENUM_CLIENTS) {
1518 if (dev->dev_state == MEI_DEV_POWER_DOWN ||
1519 dev->dev_state == MEI_DEV_POWERING_DOWN) {
1520 dev_dbg(dev->dev, "hbm: enumeration response: on shutdown, ignoring\n");
1521 return 0;
1522 }
1523 dev_err(dev->dev, "hbm: enumeration response: state mismatch, [%d, %d]\n",
1524 dev->dev_state, dev->hbm_state);
1525 return -EPROTO;
1526 }
1527
1528 dev->hbm_state = MEI_HBM_CLIENT_PROPERTIES;
1529
1530 /* first property request */
1531 if (mei_hbm_prop_req(dev, 0))
1532 return -EIO;
1533
1534 break;
1535
1536 case HOST_STOP_RES_CMD:
1537 dev_dbg(dev->dev, "hbm: stop response: message received\n");
1538
1539 dev->init_clients_timer = 0;
1540
1541 if (dev->hbm_state != MEI_HBM_STOPPED) {
1542 dev_err(dev->dev, "hbm: stop response: state mismatch, [%d, %d]\n",
1543 dev->dev_state, dev->hbm_state);
1544 return -EPROTO;
1545 }
1546
1547 mei_set_devstate(dev, MEI_DEV_POWER_DOWN);
1548 dev_info(dev->dev, "hbm: stop response: resetting.\n");
1549 /* force the reset */
1550 return -EPROTO;
1551
1552 case CLIENT_DISCONNECT_REQ_CMD:
1553 dev_dbg(dev->dev, "hbm: disconnect request: message received\n");
1554
1555 disconnect_req = (struct hbm_client_connect_request *)mei_msg;
1556 mei_hbm_fw_disconnect_req(dev, disconnect_req);
1557 break;
1558
1559 case ME_STOP_REQ_CMD:
1560 dev_dbg(dev->dev, "hbm: stop request: message received\n");
1561 dev->hbm_state = MEI_HBM_STOPPED;
1562 if (mei_hbm_stop_req(dev)) {
1563 dev_err(dev->dev, "hbm: stop request: failed to send stop request\n");
1564 return -EIO;
1565 }
1566 break;
1567
1568 case MEI_HBM_ADD_CLIENT_REQ_CMD:
1569 dev_dbg(dev->dev, "hbm: add client request received\n");
1570 /*
1571 * after the host receives the enum_resp
1572 * message clients may be added or removed
1573 */
1574 if (dev->hbm_state <= MEI_HBM_ENUM_CLIENTS ||
1575 dev->hbm_state >= MEI_HBM_STOPPED) {
1576 dev_err(dev->dev, "hbm: add client: state mismatch, [%d, %d]\n",
1577 dev->dev_state, dev->hbm_state);
1578 return -EPROTO;
1579 }
1580 add_cl_req = (struct hbm_add_client_request *)mei_msg;
1581 ret = mei_hbm_fw_add_cl_req(dev, add_cl_req);
1582 if (ret) {
1583 dev_err(dev->dev, "hbm: add client: failed to send response %d\n",
1584 ret);
1585 return -EIO;
1586 }
1587 dev_dbg(dev->dev, "hbm: add client request processed\n");
1588 break;
1589
1590 case MEI_HBM_NOTIFY_RES_CMD:
1591 dev_dbg(dev->dev, "hbm: notify response received\n");
1592 mei_hbm_cl_res(dev, cl_cmd, notify_res_to_fop(cl_cmd));
1593 break;
1594
1595 case MEI_HBM_NOTIFICATION_CMD:
1596 dev_dbg(dev->dev, "hbm: notification\n");
1597 mei_hbm_cl_notify(dev, cl_cmd);
1598 break;
1599
1600 case MEI_HBM_CLIENT_DMA_MAP_RES_CMD:
1601 dev_dbg(dev->dev, "hbm: client dma map response: message received.\n");
1602 client_dma_res = (struct hbm_client_dma_response *)mei_msg;
1603 mei_hbm_cl_dma_map_res(dev, client_dma_res);
1604 break;
1605
1606 case MEI_HBM_CLIENT_DMA_UNMAP_RES_CMD:
1607 dev_dbg(dev->dev, "hbm: client dma unmap response: message received.\n");
1608 client_dma_res = (struct hbm_client_dma_response *)mei_msg;
1609 mei_hbm_cl_dma_unmap_res(dev, client_dma_res);
1610 break;
1611
1612 default:
1613 WARN(1, "hbm: wrong command %d\n", mei_msg->hbm_cmd);
1614 return -EPROTO;
1615
1616 }
1617 return 0;
1618}
1619