Lines Matching refs:dev
91 * @dev: mei device
97 static inline int mei_hbm_write_message(struct mei_device *dev,
101 return mei_write_message(dev, hdr, sizeof(*hdr), data, hdr->length);
107 * @dev: the device structure
109 void mei_hbm_idle(struct mei_device *dev)
111 dev->init_clients_timer = 0;
112 dev->hbm_state = MEI_HBM_IDLE;
118 * @dev: the device structure
120 void mei_hbm_reset(struct mei_device *dev)
122 mei_me_cl_rm_all(dev);
124 mei_hbm_idle(dev);
164 * @dev: the device structure
172 static inline int mei_hbm_cl_write(struct mei_device *dev, struct mei_cl *cl,
180 return mei_hbm_write_message(dev, &mei_hdr, buf);
202 * @dev: the device structure
208 struct mei_cl *mei_hbm_cl_find_by_cmd(struct mei_device *dev, void *buf)
213 list_for_each_entry(cl, &dev->file_list, link)
223 * @dev: the device structure
227 int mei_hbm_start_wait(struct mei_device *dev)
231 if (dev->hbm_state > MEI_HBM_STARTING)
234 mutex_unlock(&dev->device_lock);
235 ret = wait_event_timeout(dev->wait_hbm_start,
236 dev->hbm_state != MEI_HBM_STARTING,
237 dev->timeouts.hbm);
238 mutex_lock(&dev->device_lock);
240 if (ret == 0 && (dev->hbm_state <= MEI_HBM_STARTING)) {
241 dev->hbm_state = MEI_HBM_IDLE;
242 dev_err(dev->dev, "waiting for mei start failed\n");
251 * @dev: the device structure
255 int mei_hbm_start_req(struct mei_device *dev)
261 mei_hbm_reset(dev);
271 dev->hbm_state = MEI_HBM_IDLE;
272 ret = mei_hbm_write_message(dev, &mei_hdr, &req);
274 dev_err(dev->dev, "version message write failed: ret = %d\n",
279 dev->hbm_state = MEI_HBM_STARTING;
280 dev->init_clients_timer = dev->timeouts.client_init;
281 mei_schedule_stall_timer(dev);
287 * @dev: the device structure
291 static int mei_hbm_dma_setup_req(struct mei_device *dev)
305 paddr = dev->dr_dscr[i].daddr;
308 req.dma_dscr[i].size = dev->dr_dscr[i].size;
311 mei_dma_ring_reset(dev);
313 ret = mei_hbm_write_message(dev, &mei_hdr, &req);
315 dev_err(dev->dev, "dma setup request write failed: ret = %d.\n",
320 dev->hbm_state = MEI_HBM_DR_SETUP;
321 dev->init_clients_timer = dev->timeouts.client_init;
322 mei_schedule_stall_timer(dev);
329 * @dev: the device structure
333 static int mei_hbm_capabilities_req(struct mei_device *dev)
343 if (dev->hbm_f_vt_supported)
346 if (dev->hbm_f_cd_supported)
349 if (dev->hbm_f_gsc_supported)
352 ret = mei_hbm_write_message(dev, &mei_hdr, &req);
354 dev_err(dev->dev,
359 dev->hbm_state = MEI_HBM_CAP_SETUP;
360 dev->init_clients_timer = dev->timeouts.client_init;
361 mei_schedule_stall_timer(dev);
368 * @dev: the device structure
372 static int mei_hbm_enum_clients_req(struct mei_device *dev)
383 req.flags |= dev->hbm_f_dc_supported ? MEI_HBM_ENUM_F_ALLOW_ADD : 0;
384 req.flags |= dev->hbm_f_ie_supported ?
387 ret = mei_hbm_write_message(dev, &mei_hdr, &req);
389 dev_err(dev->dev, "enumeration request write failed: ret = %d.\n",
393 dev->hbm_state = MEI_HBM_ENUM_CLIENTS;
394 dev->init_clients_timer = dev->timeouts.client_init;
395 mei_schedule_stall_timer(dev);
402 * @dev: the device structure
408 static int mei_hbm_me_cl_add(struct mei_device *dev,
414 mei_me_cl_rm_by_uuid(dev, uuid);
426 mei_me_cl_add(dev, me_cl);
434 * @dev: the device structure
440 static int mei_hbm_add_cl_resp(struct mei_device *dev, u8 addr, u8 status)
446 dev_dbg(dev->dev, "adding client response\n");
455 ret = mei_hbm_write_message(dev, &mei_hdr, &resp);
457 dev_err(dev->dev, "add client response write failed: ret = %d\n",
465 * @dev: the device structure
470 static int mei_hbm_fw_add_cl_req(struct mei_device *dev,
479 ret = mei_hbm_me_cl_add(dev, (struct hbm_props_response *)req);
483 if (dev->dev_state == MEI_DEV_ENABLED)
484 schedule_work(&dev->bus_rescan_work);
486 return mei_hbm_add_cl_resp(dev, req->me_addr, status);
492 * @dev: the device structure
498 int mei_hbm_cl_notify_req(struct mei_device *dev,
511 ret = mei_hbm_write_message(dev, &mei_hdr, &req);
513 cl_err(dev, cl, "notify request failed: ret = %d\n", ret);
538 * @dev: the device structure
542 static void mei_hbm_cl_notify_start_res(struct mei_device *dev,
549 cl_dbg(dev, cl, "hbm: notify start response status=%d\n", rs->status);
564 * @dev: the device structure
568 static void mei_hbm_cl_notify_stop_res(struct mei_device *dev,
575 cl_dbg(dev, cl, "hbm: notify stop response status=%d\n", rs->status);
590 * @dev: the device structure
593 static void mei_hbm_cl_notify(struct mei_device *dev,
598 cl = mei_hbm_cl_find_by_cmd(dev, cmd);
606 * @dev: the device structure
611 int mei_hbm_cl_dma_map_req(struct mei_device *dev, struct mei_cl *cl)
627 ret = mei_hbm_write_message(dev, &mei_hdr, &req);
629 cl_err(dev, cl, "dma map request failed: ret = %d\n", ret);
637 * @dev: the device structure
642 int mei_hbm_cl_dma_unmap_req(struct mei_device *dev, struct mei_cl *cl)
655 ret = mei_hbm_write_message(dev, &mei_hdr, &req);
657 cl_err(dev, cl, "dma unmap request failed: ret = %d\n", ret);
662 static void mei_hbm_cl_dma_map_res(struct mei_device *dev,
669 list_for_each_entry_safe(cb, next, &dev->ctrl_rd_list, list) {
682 cl_err(dev, cl, "cl dma map failed %d\n", res->status);
685 cl_dbg(dev, cl, "cl dma map succeeded\n");
692 static void mei_hbm_cl_dma_unmap_res(struct mei_device *dev,
699 list_for_each_entry_safe(cb, next, &dev->ctrl_rd_list, list) {
712 cl_err(dev, cl, "cl dma unmap failed %d\n", res->status);
715 cl_dbg(dev, cl, "cl dma unmap succeeded\n");
725 * @dev: the device structure
730 static int mei_hbm_prop_req(struct mei_device *dev, unsigned long start_idx)
737 addr = find_next_bit(dev->me_clients_map, MEI_CLIENTS_MAX, start_idx);
741 dev->hbm_state = MEI_HBM_STARTED;
742 mei_host_client_init(dev);
753 ret = mei_hbm_write_message(dev, &mei_hdr, &req);
755 dev_err(dev->dev, "properties request write failed: ret = %d\n",
760 dev->init_clients_timer = dev->timeouts.client_init;
761 mei_schedule_stall_timer(dev);
769 * @dev: the device structure
775 int mei_hbm_pg(struct mei_device *dev, u8 pg_cmd)
781 if (!dev->hbm_f_pg_supported)
789 ret = mei_hbm_write_message(dev, &mei_hdr, &req);
791 dev_err(dev->dev, "power gate command write failed.\n");
799 * @dev: mei device
803 static int mei_hbm_stop_req(struct mei_device *dev)
814 return mei_hbm_write_message(dev, &mei_hdr, &req);
820 * @dev: the device structure
825 int mei_hbm_cl_flow_control_req(struct mei_device *dev, struct mei_cl *cl)
829 cl_dbg(dev, cl, "sending flow control\n");
830 return mei_hbm_cl_write(dev, cl, MEI_FLOW_CONTROL_CMD,
837 * @dev: the device structure
842 static int mei_hbm_add_single_tx_flow_ctrl_creds(struct mei_device *dev,
848 me_cl = mei_me_cl_by_id(dev, fctrl->me_addr);
850 dev_err(dev->dev, "no such me client %d\n", fctrl->me_addr);
860 dev_dbg(dev->dev, "recv flow ctrl msg ME %d (single) creds = %d.\n",
872 * @dev: the device structure
875 static void mei_hbm_cl_tx_flow_ctrl_creds_res(struct mei_device *dev,
882 mei_hbm_add_single_tx_flow_ctrl_creds(dev, fctrl);
886 cl = mei_hbm_cl_find_by_cmd(dev, fctrl);
889 cl_dbg(dev, cl, "flow control creds = %d.\n",
898 * @dev: the device structure
903 int mei_hbm_cl_disconnect_req(struct mei_device *dev, struct mei_cl *cl)
907 return mei_hbm_cl_write(dev, cl, CLIENT_DISCONNECT_REQ_CMD,
914 * @dev: the device structure
919 int mei_hbm_cl_disconnect_rsp(struct mei_device *dev, struct mei_cl *cl)
923 return mei_hbm_cl_write(dev, cl, CLIENT_DISCONNECT_RES_CMD,
931 * @dev: the device structure
935 static void mei_hbm_cl_disconnect_res(struct mei_device *dev, struct mei_cl *cl,
941 cl_dbg(dev, cl, "hbm: disconnect response status=%d\n", rs->status);
951 * @dev: the device structure
956 int mei_hbm_cl_connect_req(struct mei_device *dev, struct mei_cl *cl)
960 return mei_hbm_cl_write(dev, cl, CLIENT_CONNECT_REQ_CMD,
968 * @dev: the device structure
972 static void mei_hbm_cl_connect_res(struct mei_device *dev, struct mei_cl *cl,
978 cl_dbg(dev, cl, "hbm: connect response status=%s\n",
986 mei_me_cl_del(dev, cl->me_cl);
987 if (dev->dev_state == MEI_DEV_ENABLED)
988 schedule_work(&dev->bus_rescan_work);
998 * @dev: the device structure
1002 static void mei_hbm_cl_res(struct mei_device *dev,
1010 list_for_each_entry_safe(cb, next, &dev->ctrl_rd_list, list) {
1028 mei_hbm_cl_connect_res(dev, cl, rs);
1031 mei_hbm_cl_disconnect_res(dev, cl, rs);
1034 mei_hbm_cl_notify_start_res(dev, cl, rs);
1037 mei_hbm_cl_notify_stop_res(dev, cl, rs);
1052 * @dev: the device structure.
1057 static int mei_hbm_fw_disconnect_req(struct mei_device *dev,
1063 cl = mei_hbm_cl_find_by_cmd(dev, disconnect_req);
1065 cl_warn(dev, cl, "fw disconnect request received\n");
1080 * @dev: the device structure.
1084 static int mei_hbm_pg_enter_res(struct mei_device *dev)
1086 if (mei_pg_state(dev) != MEI_PG_OFF ||
1087 dev->pg_event != MEI_PG_EVENT_WAIT) {
1088 dev_err(dev->dev, "hbm: pg entry response: state mismatch [%s, %d]\n",
1089 mei_pg_state_str(mei_pg_state(dev)), dev->pg_event);
1093 dev->pg_event = MEI_PG_EVENT_RECEIVED;
1094 wake_up(&dev->wait_pg);
1102 * @dev: the device structure.
1104 void mei_hbm_pg_resume(struct mei_device *dev)
1106 pm_request_resume(dev->dev);
1113 * @dev: the device structure.
1117 static int mei_hbm_pg_exit_res(struct mei_device *dev)
1119 if (mei_pg_state(dev) != MEI_PG_ON ||
1120 (dev->pg_event != MEI_PG_EVENT_WAIT &&
1121 dev->pg_event != MEI_PG_EVENT_IDLE)) {
1122 dev_err(dev->dev, "hbm: pg exit response: state mismatch [%s, %d]\n",
1123 mei_pg_state_str(mei_pg_state(dev)), dev->pg_event);
1127 switch (dev->pg_event) {
1129 dev->pg_event = MEI_PG_EVENT_RECEIVED;
1130 wake_up(&dev->wait_pg);
1138 dev->pg_event = MEI_PG_EVENT_RECEIVED;
1139 mei_hbm_pg_resume(dev);
1143 dev->pg_event);
1154 * @dev: the device structure
1156 static void mei_hbm_config_features(struct mei_device *dev)
1159 dev->hbm_f_pg_supported = 0;
1160 if (dev->version.major_version > HBM_MAJOR_VERSION_PGI)
1161 dev->hbm_f_pg_supported = 1;
1163 if (dev->version.major_version == HBM_MAJOR_VERSION_PGI &&
1164 dev->version.minor_version >= HBM_MINOR_VERSION_PGI)
1165 dev->hbm_f_pg_supported = 1;
1167 dev->hbm_f_dc_supported = 0;
1168 if (dev->version.major_version >= HBM_MAJOR_VERSION_DC)
1169 dev->hbm_f_dc_supported = 1;
1171 dev->hbm_f_ie_supported = 0;
1172 if (dev->version.major_version >= HBM_MAJOR_VERSION_IE)
1173 dev->hbm_f_ie_supported = 1;
1176 dev->hbm_f_dot_supported = 0;
1177 if (dev->version.major_version >= HBM_MAJOR_VERSION_DOT)
1178 dev->hbm_f_dot_supported = 1;
1181 dev->hbm_f_ev_supported = 0;
1182 if (dev->version.major_version >= HBM_MAJOR_VERSION_EV)
1183 dev->hbm_f_ev_supported = 1;
1186 dev->hbm_f_fa_supported = 0;
1187 if (dev->version.major_version >= HBM_MAJOR_VERSION_FA)
1188 dev->hbm_f_fa_supported = 1;
1191 dev->hbm_f_os_supported = 0;
1192 if (dev->version.major_version >= HBM_MAJOR_VERSION_OS)
1193 dev->hbm_f_os_supported = 1;
1196 dev->hbm_f_dr_supported = 0;
1197 if (dev->version.major_version > HBM_MAJOR_VERSION_DR ||
1198 (dev->version.major_version == HBM_MAJOR_VERSION_DR &&
1199 dev->version.minor_version >= HBM_MINOR_VERSION_DR))
1200 dev->hbm_f_dr_supported = 1;
1203 dev->hbm_f_vt_supported = 0;
1204 if (dev->version.major_version > HBM_MAJOR_VERSION_VT ||
1205 (dev->version.major_version == HBM_MAJOR_VERSION_VT &&
1206 dev->version.minor_version >= HBM_MINOR_VERSION_VT))
1207 dev->hbm_f_vt_supported = 1;
1210 if (dev->version.major_version > HBM_MAJOR_VERSION_GSC ||
1211 (dev->version.major_version == HBM_MAJOR_VERSION_GSC &&
1212 dev->version.minor_version >= HBM_MINOR_VERSION_GSC))
1213 dev->hbm_f_gsc_supported = 1;
1216 dev->hbm_f_cap_supported = 0;
1217 if (dev->version.major_version > HBM_MAJOR_VERSION_CAP ||
1218 (dev->version.major_version == HBM_MAJOR_VERSION_CAP &&
1219 dev->version.minor_version >= HBM_MINOR_VERSION_CAP))
1220 dev->hbm_f_cap_supported = 1;
1223 dev->hbm_f_cd_supported = 0;
1224 if (dev->version.major_version > HBM_MAJOR_VERSION_CD ||
1225 (dev->version.major_version == HBM_MAJOR_VERSION_CD &&
1226 dev->version.minor_version >= HBM_MINOR_VERSION_CD))
1227 dev->hbm_f_cd_supported = 1;
1234 * @dev: the device structure
1237 bool mei_hbm_version_is_supported(struct mei_device *dev)
1239 return (dev->version.major_version < HBM_MAJOR_VERSION) ||
1240 (dev->version.major_version == HBM_MAJOR_VERSION &&
1241 dev->version.minor_version <= HBM_MINOR_VERSION);
1248 * @dev: the device structure
1253 int mei_hbm_dispatch(struct mei_device *dev, struct mei_msg_hdr *hdr)
1270 BUG_ON(hdr->length >= sizeof(dev->rd_msg_buf));
1271 mei_read_slots(dev, dev->rd_msg_buf, hdr->length);
1272 mei_msg = (struct mei_bus_message *)dev->rd_msg_buf;
1278 if (dev->hbm_state == MEI_HBM_IDLE) {
1279 dev_dbg(dev->dev, "hbm: state is idle ignore spurious messages\n");
1285 dev_dbg(dev->dev, "hbm: start: response message received.\n");
1287 dev->init_clients_timer = 0;
1291 dev_dbg(dev->dev, "HBM VERSION: DRIVER=%02d:%02d DEVICE=%02d:%02d\n",
1297 dev->version.major_version = HBM_MAJOR_VERSION;
1298 dev->version.minor_version = HBM_MINOR_VERSION;
1300 dev->version.major_version =
1302 dev->version.minor_version =
1306 if (!mei_hbm_version_is_supported(dev)) {
1307 dev_warn(dev->dev, "hbm: start: version mismatch - stopping the driver.\n");
1309 dev->hbm_state = MEI_HBM_STOPPED;
1310 if (mei_hbm_stop_req(dev)) {
1311 dev_err(dev->dev, "hbm: start: failed to send stop request\n");
1317 mei_hbm_config_features(dev);
1319 if (dev->dev_state != MEI_DEV_INIT_CLIENTS ||
1320 dev->hbm_state != MEI_HBM_STARTING) {
1321 if (dev->dev_state == MEI_DEV_POWER_DOWN ||
1322 dev->dev_state == MEI_DEV_POWERING_DOWN) {
1323 dev_dbg(dev->dev, "hbm: start: on shutdown, ignoring\n");
1326 dev_err(dev->dev, "hbm: start: state mismatch, [%d, %d]\n",
1327 dev->dev_state, dev->hbm_state);
1331 if (dev->hbm_f_cap_supported) {
1332 if (mei_hbm_capabilities_req(dev))
1334 wake_up(&dev->wait_hbm_start);
1338 if (dev->hbm_f_dr_supported) {
1339 if (mei_dmam_ring_alloc(dev))
1340 dev_info(dev->dev, "running w/o dma ring\n");
1341 if (mei_dma_ring_is_allocated(dev)) {
1342 if (mei_hbm_dma_setup_req(dev))
1345 wake_up(&dev->wait_hbm_start);
1350 dev->hbm_f_dr_supported = 0;
1351 mei_dmam_ring_free(dev);
1353 if (mei_hbm_enum_clients_req(dev))
1356 wake_up(&dev->wait_hbm_start);
1360 dev_dbg(dev->dev, "hbm: capabilities response: message received.\n");
1362 dev->init_clients_timer = 0;
1364 if (dev->dev_state != MEI_DEV_INIT_CLIENTS ||
1365 dev->hbm_state != MEI_HBM_CAP_SETUP) {
1366 if (dev->dev_state == MEI_DEV_POWER_DOWN ||
1367 dev->dev_state == MEI_DEV_POWERING_DOWN) {
1368 dev_dbg(dev->dev, "hbm: capabilities response: on shutdown, ignoring\n");
1371 dev_err(dev->dev, "hbm: capabilities response: state mismatch, [%d, %d]\n",
1372 dev->dev_state, dev->hbm_state);
1378 dev->hbm_f_vt_supported = 0;
1380 dev->hbm_f_cd_supported = 0;
1383 dev->hbm_f_gsc_supported = 0;
1385 if (dev->hbm_f_dr_supported) {
1386 if (mei_dmam_ring_alloc(dev))
1387 dev_info(dev->dev, "running w/o dma ring\n");
1388 if (mei_dma_ring_is_allocated(dev)) {
1389 if (mei_hbm_dma_setup_req(dev))
1395 dev->hbm_f_dr_supported = 0;
1396 mei_dmam_ring_free(dev);
1398 if (mei_hbm_enum_clients_req(dev))
1403 dev_dbg(dev->dev, "hbm: dma setup response: message received.\n");
1405 dev->init_clients_timer = 0;
1407 if (dev->dev_state != MEI_DEV_INIT_CLIENTS ||
1408 dev->hbm_state != MEI_HBM_DR_SETUP) {
1409 if (dev->dev_state == MEI_DEV_POWER_DOWN ||
1410 dev->dev_state == MEI_DEV_POWERING_DOWN) {
1411 dev_dbg(dev->dev, "hbm: dma setup response: on shutdown, ignoring\n");
1414 dev_err(dev->dev, "hbm: dma setup response: state mismatch, [%d, %d]\n",
1415 dev->dev_state, dev->hbm_state);
1425 dev_dbg(dev->dev, "hbm: dma setup not allowed\n");
1427 dev_info(dev->dev, "hbm: dma setup response: failure = %d %s\n",
1431 dev->hbm_f_dr_supported = 0;
1432 mei_dmam_ring_free(dev);
1435 if (mei_hbm_enum_clients_req(dev))
1440 dev_dbg(dev->dev, "hbm: client connect response: message received.\n");
1441 mei_hbm_cl_res(dev, cl_cmd, MEI_FOP_CONNECT);
1445 dev_dbg(dev->dev, "hbm: client disconnect response: message received.\n");
1446 mei_hbm_cl_res(dev, cl_cmd, MEI_FOP_DISCONNECT);
1450 dev_dbg(dev->dev, "hbm: client flow control response: message received.\n");
1453 mei_hbm_cl_tx_flow_ctrl_creds_res(dev, fctrl);
1457 dev_dbg(dev->dev, "hbm: power gate isolation entry response received\n");
1458 ret = mei_hbm_pg_enter_res(dev);
1464 dev_dbg(dev->dev, "hbm: power gate isolation exit request received\n");
1465 ret = mei_hbm_pg_exit_res(dev);
1471 dev_dbg(dev->dev, "hbm: properties response: message received.\n");
1473 dev->init_clients_timer = 0;
1475 if (dev->dev_state != MEI_DEV_INIT_CLIENTS ||
1476 dev->hbm_state != MEI_HBM_CLIENT_PROPERTIES) {
1477 if (dev->dev_state == MEI_DEV_POWER_DOWN ||
1478 dev->dev_state == MEI_DEV_POWERING_DOWN) {
1479 dev_dbg(dev->dev, "hbm: properties response: on shutdown, ignoring\n");
1482 dev_err(dev->dev, "hbm: properties response: state mismatch, [%d, %d]\n",
1483 dev->dev_state, dev->hbm_state);
1490 dev_dbg(dev->dev, "hbm: properties response: %d CLIENT_NOT_FOUND\n",
1493 dev_err(dev->dev, "hbm: properties response: wrong status = %d %s\n",
1498 mei_hbm_me_cl_add(dev, props_res);
1502 if (mei_hbm_prop_req(dev, props_res->me_addr + 1))
1508 dev_dbg(dev->dev, "hbm: enumeration response: message received\n");
1510 dev->init_clients_timer = 0;
1513 BUILD_BUG_ON(sizeof(dev->me_clients_map)
1515 memcpy(dev->me_clients_map, enum_res->valid_addresses,
1518 if (dev->dev_state != MEI_DEV_INIT_CLIENTS ||
1519 dev->hbm_state != MEI_HBM_ENUM_CLIENTS) {
1520 if (dev->dev_state == MEI_DEV_POWER_DOWN ||
1521 dev->dev_state == MEI_DEV_POWERING_DOWN) {
1522 dev_dbg(dev->dev, "hbm: enumeration response: on shutdown, ignoring\n");
1525 dev_err(dev->dev, "hbm: enumeration response: state mismatch, [%d, %d]\n",
1526 dev->dev_state, dev->hbm_state);
1530 dev->hbm_state = MEI_HBM_CLIENT_PROPERTIES;
1533 if (mei_hbm_prop_req(dev, 0))
1539 dev_dbg(dev->dev, "hbm: stop response: message received\n");
1541 dev->init_clients_timer = 0;
1543 if (dev->hbm_state != MEI_HBM_STOPPED) {
1544 dev_err(dev->dev, "hbm: stop response: state mismatch, [%d, %d]\n",
1545 dev->dev_state, dev->hbm_state);
1549 mei_set_devstate(dev, MEI_DEV_POWER_DOWN);
1550 dev_info(dev->dev, "hbm: stop response: resetting.\n");
1555 dev_dbg(dev->dev, "hbm: disconnect request: message received\n");
1558 mei_hbm_fw_disconnect_req(dev, disconnect_req);
1562 dev_dbg(dev->dev, "hbm: stop request: message received\n");
1563 dev->hbm_state = MEI_HBM_STOPPED;
1564 if (mei_hbm_stop_req(dev)) {
1565 dev_err(dev->dev, "hbm: stop request: failed to send stop request\n");
1571 dev_dbg(dev->dev, "hbm: add client request received\n");
1576 if (dev->hbm_state <= MEI_HBM_ENUM_CLIENTS ||
1577 dev->hbm_state >= MEI_HBM_STOPPED) {
1578 dev_err(dev->dev, "hbm: add client: state mismatch, [%d, %d]\n",
1579 dev->dev_state, dev->hbm_state);
1583 ret = mei_hbm_fw_add_cl_req(dev, add_cl_req);
1585 dev_err(dev->dev, "hbm: add client: failed to send response %d\n",
1589 dev_dbg(dev->dev, "hbm: add client request processed\n");
1593 dev_dbg(dev->dev, "hbm: notify response received\n");
1594 mei_hbm_cl_res(dev, cl_cmd, notify_res_to_fop(cl_cmd));
1598 dev_dbg(dev->dev, "hbm: notification\n");
1599 mei_hbm_cl_notify(dev, cl_cmd);
1603 dev_dbg(dev->dev, "hbm: client dma map response: message received.\n");
1605 mei_hbm_cl_dma_map_res(dev, client_dma_res);
1609 dev_dbg(dev->dev, "hbm: client dma unmap response: message received.\n");
1611 mei_hbm_cl_dma_unmap_res(dev, client_dma_res);