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