Lines Matching refs:cl
341 cb->cl->tx_cb_queued++;
353 if (!WARN_ON(cb->cl->tx_cb_queued == 0))
354 cb->cl->tx_cb_queued--;
362 * @cl: mei client
367 static void mei_cl_set_read_by_fp(const struct mei_cl *cl,
372 list_for_each_entry(cl_vtag, &cl->vtag_map, list) {
383 * @cl: mei client
389 static struct mei_cl_cb *mei_io_cb_init(struct mei_cl *cl,
401 cb->cl = cl;
411 * mei_io_list_flush_cl - removes cbs belonging to the cl.
414 * @cl: host client
417 const struct mei_cl *cl)
422 if (cl == cb->cl) {
431 * mei_io_tx_list_free_cl - removes cb belonging to the cl and free them
434 * @cl: host client
438 const struct mei_cl *cl,
444 if (cl == cb->cl && (!fp || fp == cb->fp))
467 * @cl: host client
469 static void mei_cl_free_pending(struct mei_cl *cl)
473 cb = list_first_entry_or_null(&cl->rd_pending, struct mei_cl_cb, list);
480 * @cl: host client
487 struct mei_cl_cb *mei_cl_alloc_cb(struct mei_cl *cl, size_t length,
493 cb = mei_io_cb_init(cl, fop_type, fp);
514 * @cl: host client
522 struct mei_cl_cb *mei_cl_enqueue_ctrl_wr_cb(struct mei_cl *cl, size_t length,
530 length = max_t(size_t, length, mei_cl_mtu(cl));
532 cb = mei_cl_alloc_cb(cl, length, fop_type, fp);
536 list_add_tail(&cb->list, &cl->dev->ctrl_wr_list);
541 * mei_cl_read_cb - find this cl's callback in the read list
544 * @cl: host client
549 struct mei_cl_cb *mei_cl_read_cb(struct mei_cl *cl, const struct file *fp)
554 spin_lock(&cl->rd_completed_lock);
555 list_for_each_entry(cb, &cl->rd_completed, list)
560 spin_unlock(&cl->rd_completed_lock);
565 * mei_cl_flush_queues - flushes queue lists belonging to cl.
567 * @cl: host client
570 * Return: 0 on success, -EINVAL if cl or cl->dev is NULL.
572 int mei_cl_flush_queues(struct mei_cl *cl, const struct file *fp)
576 if (WARN_ON(!cl || !cl->dev))
579 dev = cl->dev;
581 cl_dbg(dev, cl, "remove list entry belonging to cl\n");
582 mei_io_tx_list_free_cl(&cl->dev->write_list, cl, fp);
583 mei_io_tx_list_free_cl(&cl->dev->write_waiting_list, cl, fp);
586 mei_io_list_flush_cl(&cl->dev->ctrl_wr_list, cl);
587 mei_io_list_flush_cl(&cl->dev->ctrl_rd_list, cl);
588 mei_cl_free_pending(cl);
590 spin_lock(&cl->rd_completed_lock);
591 mei_io_list_free_fp(&cl->rd_completed, fp);
592 spin_unlock(&cl->rd_completed_lock);
598 * mei_cl_init - initializes cl.
600 * @cl: host client to be initialized
603 static void mei_cl_init(struct mei_cl *cl, struct mei_device *dev)
605 memset(cl, 0, sizeof(*cl));
606 init_waitqueue_head(&cl->wait);
607 init_waitqueue_head(&cl->rx_wait);
608 init_waitqueue_head(&cl->tx_wait);
609 init_waitqueue_head(&cl->ev_wait);
610 INIT_LIST_HEAD(&cl->vtag_map);
611 spin_lock_init(&cl->rd_completed_lock);
612 INIT_LIST_HEAD(&cl->rd_completed);
613 INIT_LIST_HEAD(&cl->rd_pending);
614 INIT_LIST_HEAD(&cl->link);
615 cl->writing_state = MEI_IDLE;
616 cl->state = MEI_FILE_UNINITIALIZED;
617 cl->dev = dev;
621 * mei_cl_allocate - allocates cl structure and sets it up.
628 struct mei_cl *cl;
630 cl = kmalloc(sizeof(*cl), GFP_KERNEL);
631 if (!cl)
634 mei_cl_init(cl, dev);
636 return cl;
642 * @cl: host client
648 int mei_cl_link(struct mei_cl *cl)
653 if (WARN_ON(!cl || !cl->dev))
656 dev = cl->dev;
672 cl->host_client_id = id;
673 list_add_tail(&cl->link, &dev->file_list);
677 cl->state = MEI_FILE_INITIALIZING;
679 cl_dbg(dev, cl, "link cl\n");
686 * @cl: host client
690 int mei_cl_unlink(struct mei_cl *cl)
695 if (!cl)
698 if (WARN_ON(!cl->dev))
701 dev = cl->dev;
703 cl_dbg(dev, cl, "unlink client");
705 if (cl->state == MEI_FILE_UNINITIALIZED)
712 if (cl->host_client_id)
713 clear_bit(cl->host_client_id, dev->host_clients_map);
715 list_del_init(&cl->link);
717 cl->state = MEI_FILE_UNINITIALIZED;
718 cl->writing_state = MEI_IDLE;
720 WARN_ON(!list_empty(&cl->rd_completed) ||
721 !list_empty(&cl->rd_pending) ||
722 !list_empty(&cl->link));
767 * @cl: host client
769 static void mei_cl_wake_all(struct mei_cl *cl)
771 struct mei_device *dev = cl->dev;
774 if (waitqueue_active(&cl->rx_wait)) {
775 cl_dbg(dev, cl, "Waking up reading client!\n");
776 wake_up_interruptible(&cl->rx_wait);
779 if (waitqueue_active(&cl->tx_wait)) {
780 cl_dbg(dev, cl, "Waking up writing client!\n");
781 wake_up_interruptible(&cl->tx_wait);
784 if (waitqueue_active(&cl->ev_wait)) {
785 cl_dbg(dev, cl, "Waking up waiting for event clients!\n");
786 wake_up_interruptible(&cl->ev_wait);
789 if (waitqueue_active(&cl->wait)) {
790 cl_dbg(dev, cl, "Waking up ctrl write clients!\n");
791 wake_up(&cl->wait);
799 * @cl: host client
801 static void mei_cl_set_disconnected(struct mei_cl *cl)
803 struct mei_device *dev = cl->dev;
805 if (cl->state == MEI_FILE_DISCONNECTED ||
806 cl->state <= MEI_FILE_INITIALIZING)
809 cl->state = MEI_FILE_DISCONNECTED;
810 mei_io_tx_list_free_cl(&dev->write_list, cl, NULL);
811 mei_io_tx_list_free_cl(&dev->write_waiting_list, cl, NULL);
812 mei_io_list_flush_cl(&dev->ctrl_rd_list, cl);
813 mei_io_list_flush_cl(&dev->ctrl_wr_list, cl);
814 mei_cl_wake_all(cl);
815 cl->rx_flow_ctrl_creds = 0;
816 cl->tx_flow_ctrl_creds = 0;
817 cl->timer_count = 0;
819 if (!cl->me_cl)
822 if (!WARN_ON(cl->me_cl->connect_count == 0))
823 cl->me_cl->connect_count--;
825 if (cl->me_cl->connect_count == 0)
826 cl->me_cl->tx_flow_ctrl_creds = 0;
828 mei_me_cl_put(cl->me_cl);
829 cl->me_cl = NULL;
832 static int mei_cl_set_connecting(struct mei_cl *cl, struct mei_me_client *me_cl)
845 cl->me_cl = me_cl;
846 cl->state = MEI_FILE_CONNECTING;
847 cl->me_cl->connect_count++;
855 * @cl: host client
860 static int mei_cl_send_disconnect(struct mei_cl *cl, struct mei_cl_cb *cb)
865 dev = cl->dev;
867 ret = mei_hbm_cl_disconnect_req(dev, cl);
868 cl->status = ret;
870 cl->state = MEI_FILE_DISCONNECT_REPLY;
875 cl->timer_count = dev->timeouts.connect;
885 * @cl: client
891 int mei_cl_irq_disconnect(struct mei_cl *cl, struct mei_cl_cb *cb,
894 struct mei_device *dev = cl->dev;
907 ret = mei_cl_send_disconnect(cl, cb);
918 * @cl: host client
922 static int __mei_cl_disconnect(struct mei_cl *cl)
928 dev = cl->dev;
930 cl->state = MEI_FILE_DISCONNECTING;
932 cb = mei_cl_enqueue_ctrl_wr_cb(cl, 0, MEI_FOP_DISCONNECT, NULL);
939 rets = mei_cl_send_disconnect(cl, cb);
941 cl_err(dev, cl, "failed to disconnect.\n");
947 wait_event_timeout(cl->wait,
948 cl->state == MEI_FILE_DISCONNECT_REPLY ||
949 cl->state == MEI_FILE_DISCONNECTED,
953 rets = cl->status;
954 if (cl->state != MEI_FILE_DISCONNECT_REPLY &&
955 cl->state != MEI_FILE_DISCONNECTED) {
956 cl_dbg(dev, cl, "timeout on disconnect from FW client.\n");
962 mei_cl_set_disconnected(cl);
964 cl_dbg(dev, cl, "successfully disconnected from FW client.\n");
973 * @cl: host client
979 int mei_cl_disconnect(struct mei_cl *cl)
984 if (WARN_ON(!cl || !cl->dev))
987 dev = cl->dev;
989 cl_dbg(dev, cl, "disconnecting");
991 if (!mei_cl_is_connected(cl))
994 if (mei_cl_is_fixed_address(cl)) {
995 mei_cl_set_disconnected(cl);
1001 cl_dbg(dev, cl, "Device is powering down, don't bother with disconnection\n");
1002 mei_cl_set_disconnected(cl);
1009 cl_err(dev, cl, "rpm: get failed %d\n", rets);
1013 rets = __mei_cl_disconnect(cl);
1015 cl_dbg(dev, cl, "rpm: autosuspend\n");
1027 * @cl: private data of the file object
1031 static bool mei_cl_is_other_connecting(struct mei_cl *cl)
1036 dev = cl->dev;
1040 mei_cl_me_id(cl) == mei_cl_me_id(cb->cl))
1050 * @cl: host client
1055 static int mei_cl_send_connect(struct mei_cl *cl, struct mei_cl_cb *cb)
1060 dev = cl->dev;
1062 ret = mei_hbm_cl_connect_req(dev, cl);
1063 cl->status = ret;
1065 cl->state = MEI_FILE_DISCONNECT_REPLY;
1070 cl->timer_count = dev->timeouts.connect;
1078 * @cl: host client
1084 int mei_cl_irq_connect(struct mei_cl *cl, struct mei_cl_cb *cb,
1087 struct mei_device *dev = cl->dev;
1092 if (mei_cl_is_other_connecting(cl))
1103 rets = mei_cl_send_connect(cl, cb);
1113 * @cl: host client
1121 int mei_cl_connect(struct mei_cl *cl, struct mei_me_client *me_cl,
1128 if (WARN_ON(!cl || !cl->dev || !me_cl))
1131 dev = cl->dev;
1133 rets = mei_cl_set_connecting(cl, me_cl);
1137 if (mei_cl_is_fixed_address(cl)) {
1138 cl->state = MEI_FILE_CONNECTED;
1146 cl_err(dev, cl, "rpm: get failed %d\n", rets);
1150 cb = mei_cl_enqueue_ctrl_wr_cb(cl, 0, MEI_FOP_CONNECT, fp);
1157 if (!mei_cl_is_other_connecting(cl) && mei_hbuf_acquire(dev)) {
1158 rets = mei_cl_send_connect(cl, cb);
1164 wait_event_timeout(cl->wait,
1165 (cl->state == MEI_FILE_CONNECTED ||
1166 cl->state == MEI_FILE_DISCONNECTED ||
1167 cl->state == MEI_FILE_DISCONNECT_REQUIRED ||
1168 cl->state == MEI_FILE_DISCONNECT_REPLY),
1172 if (!mei_cl_is_connected(cl)) {
1173 if (cl->state == MEI_FILE_DISCONNECT_REQUIRED) {
1174 mei_io_list_flush_cl(&dev->ctrl_rd_list, cl);
1175 mei_io_list_flush_cl(&dev->ctrl_wr_list, cl);
1179 __mei_cl_disconnect(cl);
1185 if (!cl->status)
1186 cl->status = -EFAULT;
1189 rets = cl->status;
1191 cl_dbg(dev, cl, "rpm: autosuspend\n");
1198 if (!mei_cl_is_connected(cl))
1199 mei_cl_set_disconnected(cl);
1209 * Return: cl on success ERR_PTR on failure
1213 struct mei_cl *cl;
1216 cl = mei_cl_allocate(dev);
1217 if (!cl) {
1222 ret = mei_cl_link(cl);
1226 return cl;
1228 kfree(cl);
1233 * mei_cl_tx_flow_ctrl_creds - checks flow_control credits for cl.
1235 * @cl: host client
1239 static int mei_cl_tx_flow_ctrl_creds(struct mei_cl *cl)
1241 if (WARN_ON(!cl || !cl->me_cl))
1244 if (cl->tx_flow_ctrl_creds > 0)
1247 if (mei_cl_is_fixed_address(cl))
1250 if (mei_cl_is_single_recv_buf(cl)) {
1251 if (cl->me_cl->tx_flow_ctrl_creds > 0)
1261 * @cl: host client
1267 static int mei_cl_tx_flow_ctrl_creds_reduce(struct mei_cl *cl)
1269 if (WARN_ON(!cl || !cl->me_cl))
1272 if (mei_cl_is_fixed_address(cl))
1275 if (mei_cl_is_single_recv_buf(cl)) {
1276 if (WARN_ON(cl->me_cl->tx_flow_ctrl_creds <= 0))
1278 cl->me_cl->tx_flow_ctrl_creds--;
1280 if (WARN_ON(cl->tx_flow_ctrl_creds <= 0))
1282 cl->tx_flow_ctrl_creds--;
1315 * @cl: host client
1322 const struct file *mei_cl_fp_by_vtag(const struct mei_cl *cl, u8 vtag)
1326 list_for_each_entry(vtag_l, &cl->vtag_map, list)
1328 if ((cl->cldev && mei_cldev_enabled(cl->cldev)) ||
1338 * @cl: host client
1341 static void mei_cl_reset_read_by_vtag(const struct mei_cl *cl, u8 vtag)
1345 list_for_each_entry(vtag_l, &cl->vtag_map, list) {
1347 if ((cl->cldev && mei_cldev_enabled(cl->cldev)) ||
1359 * @cl: host client
1361 static void mei_cl_read_vtag_add_fc(struct mei_cl *cl)
1365 list_for_each_entry(cl_vtag, &cl->vtag_map, list) {
1367 if (mei_cl_enqueue_ctrl_wr_cb(cl,
1368 mei_cl_mtu(cl),
1371 cl->rx_flow_ctrl_creds++;
1380 * @cl: host client
1386 int mei_cl_vt_support_check(const struct mei_cl *cl)
1388 struct mei_device *dev = cl->dev;
1393 if (!cl->me_cl)
1396 return cl->me_cl->props.vt_supported ? 0 : -EOPNOTSUPP;
1403 * @cl: host client
1407 void mei_cl_add_rd_completed(struct mei_cl *cl, struct mei_cl_cb *cb)
1411 if (!mei_cl_vt_support_check(cl)) {
1412 fp = mei_cl_fp_by_vtag(cl, cb->vtag);
1419 mei_cl_reset_read_by_vtag(cl, cb->vtag);
1420 mei_cl_read_vtag_add_fc(cl);
1423 spin_lock(&cl->rd_completed_lock);
1424 list_add_tail(&cb->list, &cl->rd_completed);
1425 spin_unlock(&cl->rd_completed_lock);
1431 * @cl: host client
1435 void mei_cl_del_rd_completed(struct mei_cl *cl, struct mei_cl_cb *cb)
1437 spin_lock(&cl->rd_completed_lock);
1439 spin_unlock(&cl->rd_completed_lock);
1475 * @cl: client
1481 int mei_cl_irq_notify(struct mei_cl *cl, struct mei_cl_cb *cb,
1484 struct mei_device *dev = cl->dev;
1499 ret = mei_hbm_cl_notify_req(dev, cl, request);
1501 cl->status = ret;
1513 * @cl: host client
1521 int mei_cl_notify_request(struct mei_cl *cl,
1529 if (WARN_ON(!cl || !cl->dev))
1532 dev = cl->dev;
1535 cl_dbg(dev, cl, "notifications not supported\n");
1539 if (!mei_cl_is_connected(cl))
1545 cl_err(dev, cl, "rpm: get failed %d\n", rets);
1550 cb = mei_cl_enqueue_ctrl_wr_cb(cl, 0, fop_type, fp);
1557 if (mei_hbm_cl_notify_req(dev, cl, request)) {
1565 wait_event_timeout(cl->wait,
1566 cl->notify_en == request ||
1567 cl->status ||
1568 !mei_cl_is_connected(cl),
1572 if (cl->notify_en != request && !cl->status)
1573 cl->status = -EFAULT;
1575 rets = cl->status;
1578 cl_dbg(dev, cl, "rpm: autosuspend\n");
1589 * @cl: host client
1593 void mei_cl_notify(struct mei_cl *cl)
1597 if (!cl || !cl->dev)
1600 dev = cl->dev;
1602 if (!cl->notify_en)
1605 cl_dbg(dev, cl, "notify event");
1606 cl->notify_ev = true;
1607 if (!mei_cl_bus_notify_event(cl))
1608 wake_up_interruptible(&cl->ev_wait);
1610 if (cl->ev_async)
1611 kill_fasync(&cl->ev_async, SIGIO, POLL_PRI);
1618 * @cl: host client
1626 int mei_cl_notify_get(struct mei_cl *cl, bool block, bool *notify_ev)
1633 if (WARN_ON(!cl || !cl->dev))
1636 dev = cl->dev;
1639 cl_dbg(dev, cl, "notifications not supported\n");
1643 if (!mei_cl_is_connected(cl))
1646 if (cl->notify_ev)
1653 rets = wait_event_interruptible(cl->ev_wait, cl->notify_ev);
1660 *notify_ev = cl->notify_ev;
1661 cl->notify_ev = false;
1668 * @cl: host client
1674 int mei_cl_read_start(struct mei_cl *cl, size_t length, const struct file *fp)
1680 if (WARN_ON(!cl || !cl->dev))
1683 dev = cl->dev;
1685 if (!mei_cl_is_connected(cl))
1688 if (!mei_me_cl_is_active(cl->me_cl)) {
1689 cl_err(dev, cl, "no such me client\n");
1693 if (mei_cl_is_fixed_address(cl))
1697 if (cl->rx_flow_ctrl_creds) {
1698 mei_cl_set_read_by_fp(cl, fp);
1702 cb = mei_cl_enqueue_ctrl_wr_cb(cl, length, MEI_FOP_READ, fp);
1706 mei_cl_set_read_by_fp(cl, fp);
1711 cl_err(dev, cl, "rpm: get failed %d\n", rets);
1717 rets = mei_hbm_cl_flow_control_req(dev, cl);
1721 list_move_tail(&cb->list, &cl->rd_pending);
1723 cl->rx_flow_ctrl_creds++;
1726 cl_dbg(dev, cl, "rpm: autosuspend\n");
1778 is_hbm = cb->cl->me_cl->client_id == 0;
1779 is_gsc = ((!is_hbm) && cb->cl->dev->hbm_f_gsc_supported && mei_ext_hdr_is_gsc(cb->ext_hdr));
1800 mei_hdr->host_addr = mei_cl_host_addr(cb->cl);
1801 mei_hdr->me_addr = mei_cl_me_id(cb->cl);
1832 * @cl: client
1838 int mei_cl_irq_write(struct mei_cl *cl, struct mei_cl_cb *cb,
1855 if (WARN_ON(!cl || !cl->dev))
1858 dev = cl->dev;
1864 rets = first_chunk ? mei_cl_tx_flow_ctrl_creds(cl) : 1;
1869 cl_dbg(dev, cl, "No flow control credentials: not sending.\n");
1929 cl->status = 0;
1930 cl->writing_state = MEI_WRITING;
1934 if (mei_cl_tx_flow_ctrl_creds_reduce(cl)) {
1948 cl->status = rets;
1957 * @cl: host client
1965 ssize_t mei_cl_write(struct mei_cl *cl, struct mei_cl_cb *cb, unsigned long timeout)
1981 if (WARN_ON(!cl || !cl->dev))
1987 dev = cl->dev;
1992 cl_dbg(dev, cl, "buf_len=%zd\n", buf_len);
2000 cl_err(dev, cl, "rpm: get failed %zd\n", rets);
2005 cl->writing_state = MEI_IDLE;
2008 rets = mei_cl_tx_flow_ctrl_creds(cl);
2022 cl_dbg(dev, cl, "No flow control credentials: not sending.\n");
2028 cl_dbg(dev, cl, "Cannot acquire the host buffer: not sending.\n");
2070 rets = mei_cl_tx_flow_ctrl_creds_reduce(cl);
2074 cl->writing_state = MEI_WRITING;
2086 if (blocking && cl->writing_state != MEI_WRITE_COMPLETE) {
2089 rets = wait_event_interruptible_timeout(cl->tx_wait,
2090 cl->writing_state == MEI_WRITE_COMPLETE ||
2091 (!mei_cl_is_connected(cl)),
2097 mei_io_tx_list_free_cl(&dev->write_list, cl, NULL);
2098 mei_io_tx_list_free_cl(&dev->write_waiting_list, cl, NULL);
2108 if (cl->writing_state != MEI_WRITE_COMPLETE) {
2116 cl_dbg(dev, cl, "rpm: autosuspend\n");
2130 * @cl: private data of the file object.
2133 void mei_cl_complete(struct mei_cl *cl, struct mei_cl_cb *cb)
2135 struct mei_device *dev = cl->dev;
2140 cl->writing_state = MEI_WRITE_COMPLETE;
2141 if (waitqueue_active(&cl->tx_wait)) {
2142 wake_up_interruptible(&cl->tx_wait);
2150 mei_cl_add_rd_completed(cl, cb);
2151 if (!mei_cl_is_fixed_address(cl) &&
2152 !WARN_ON(!cl->rx_flow_ctrl_creds))
2153 cl->rx_flow_ctrl_creds--;
2154 if (!mei_cl_bus_rx_event(cl))
2155 wake_up_interruptible(&cl->rx_wait);
2164 if (waitqueue_active(&cl->wait))
2165 wake_up(&cl->wait);
2170 mei_cl_set_disconnected(cl);
2185 struct mei_cl *cl;
2187 list_for_each_entry(cl, &dev->file_list, link)
2188 mei_cl_set_disconnected(cl);
2194 struct mei_cl *cl;
2196 list_for_each_entry(cl, &dev->file_list, link)
2197 if (cl->dma.buffer_id == buffer_id)
2198 return cl;
2205 * @cl: client
2211 int mei_cl_irq_dma_map(struct mei_cl *cl, struct mei_cl_cb *cb,
2214 struct mei_device *dev = cl->dev;
2227 ret = mei_hbm_cl_dma_map_req(dev, cl);
2229 cl->status = ret;
2241 * @cl: client
2247 int mei_cl_irq_dma_unmap(struct mei_cl *cl, struct mei_cl_cb *cb,
2250 struct mei_device *dev = cl->dev;
2263 ret = mei_hbm_cl_dma_unmap_req(dev, cl);
2265 cl->status = ret;
2274 static int mei_cl_dma_alloc(struct mei_cl *cl, u8 buf_id, size_t size)
2276 cl->dma.vaddr = dmam_alloc_coherent(cl->dev->dev, size,
2277 &cl->dma.daddr, GFP_KERNEL);
2278 if (!cl->dma.vaddr)
2281 cl->dma.buffer_id = buf_id;
2282 cl->dma.size = size;
2287 static void mei_cl_dma_free(struct mei_cl *cl)
2289 cl->dma.buffer_id = 0;
2290 dmam_free_coherent(cl->dev->dev,
2291 cl->dma.size, cl->dma.vaddr, cl->dma.daddr);
2292 cl->dma.size = 0;
2293 cl->dma.vaddr = NULL;
2294 cl->dma.daddr = 0;
2300 * @cl: host client
2314 int mei_cl_dma_alloc_and_map(struct mei_cl *cl, const struct file *fp,
2321 if (WARN_ON(!cl || !cl->dev))
2324 dev = cl->dev;
2327 cl_dbg(dev, cl, "client dma is not supported\n");
2334 if (mei_cl_is_connected(cl))
2337 if (cl->dma_mapped)
2341 cl_dbg(dev, cl, "client dma with id %d is already allocated\n",
2342 cl->dma.buffer_id);
2349 cl_err(dev, cl, "rpm: get failed %d\n", rets);
2353 rets = mei_cl_dma_alloc(cl, buffer_id, size);
2359 cb = mei_cl_enqueue_ctrl_wr_cb(cl, 0, MEI_FOP_DMA_MAP, fp);
2366 if (mei_hbm_cl_dma_map_req(dev, cl)) {
2373 cl->status = 0;
2376 wait_event_timeout(cl->wait,
2377 cl->dma_mapped || cl->status,
2381 if (!cl->dma_mapped && !cl->status)
2382 cl->status = -EFAULT;
2384 rets = cl->status;
2388 mei_cl_dma_free(cl);
2390 cl_dbg(dev, cl, "rpm: autosuspend\n");
2401 * @cl: host client
2408 int mei_cl_dma_unmap(struct mei_cl *cl, const struct file *fp)
2414 if (WARN_ON(!cl || !cl->dev))
2417 dev = cl->dev;
2420 cl_dbg(dev, cl, "client dma is not supported\n");
2425 if (mei_cl_is_connected(cl))
2428 if (!cl->dma_mapped)
2434 cl_err(dev, cl, "rpm: get failed %d\n", rets);
2438 cb = mei_cl_enqueue_ctrl_wr_cb(cl, 0, MEI_FOP_DMA_UNMAP, fp);
2445 if (mei_hbm_cl_dma_unmap_req(dev, cl)) {
2452 cl->status = 0;
2455 wait_event_timeout(cl->wait,
2456 !cl->dma_mapped || cl->status,
2460 if (cl->dma_mapped && !cl->status)
2461 cl->status = -EFAULT;
2463 rets = cl->status;
2466 mei_cl_dma_free(cl);
2468 cl_dbg(dev, cl, "rpm: autosuspend\n");