Lines Matching refs:cb
315 * @cb: mei callback struct
317 void mei_io_cb_free(struct mei_cl_cb *cb)
319 if (cb == NULL)
322 list_del(&cb->list);
323 kfree(cb->buf.data);
324 kfree(cb);
332 * @cb: mei callback struct
335 static inline void mei_tx_cb_enqueue(struct mei_cl_cb *cb,
338 list_add_tail(&cb->list, head);
339 cb->cl->tx_cb_queued++;
347 * @cb: mei callback struct to dequeue and free
349 static inline void mei_tx_cb_dequeue(struct mei_cl_cb *cb)
351 if (!WARN_ON(cb->cl->tx_cb_queued == 0))
352 cb->cl->tx_cb_queued--;
354 mei_io_cb_free(cb);
391 struct mei_cl_cb *cb;
393 cb = kzalloc(sizeof(*cb), GFP_KERNEL);
394 if (!cb)
397 INIT_LIST_HEAD(&cb->list);
398 cb->fp = fp;
399 cb->cl = cl;
400 cb->buf_idx = 0;
401 cb->fop_type = type;
402 cb->vtag = 0;
404 return cb;
416 struct mei_cl_cb *cb, *next;
418 list_for_each_entry_safe(cb, next, head, list) {
419 if (cl == cb->cl) {
420 list_del_init(&cb->list);
421 if (cb->fop_type == MEI_FOP_READ)
422 mei_io_cb_free(cb);
428 * mei_io_tx_list_free_cl - removes cb belonging to the cl and free them
432 * @fp: file pointer (matching cb file object), may be NULL
438 struct mei_cl_cb *cb, *next;
440 list_for_each_entry_safe(cb, next, head, list) {
441 if (cl == cb->cl && (!fp || fp == cb->fp))
442 mei_tx_cb_dequeue(cb);
447 * mei_io_list_free_fp - free cb from a list that matches file pointer
450 * @fp: file pointer (matching cb file object), may be NULL
454 struct mei_cl_cb *cb, *next;
456 list_for_each_entry_safe(cb, next, head, list)
457 if (!fp || fp == cb->fp)
458 mei_io_cb_free(cb);
462 * mei_cl_free_pending - free pending cb
468 struct mei_cl_cb *cb;
470 cb = list_first_entry_or_null(&cl->rd_pending, struct mei_cl_cb, list);
471 mei_io_cb_free(cb);
475 * mei_cl_alloc_cb - a convenient wrapper for allocating read cb
482 * Return: cb on success and NULL on failure
488 struct mei_cl_cb *cb;
490 cb = mei_io_cb_init(cl, fop_type, fp);
491 if (!cb)
495 return cb;
497 cb->buf.data = kmalloc(roundup(length, MEI_SLOT_SIZE), GFP_KERNEL);
498 if (!cb->buf.data) {
499 mei_io_cb_free(cb);
502 cb->buf.size = length;
504 return cb;
509 * and enqueuing of the control commands cb
516 * Return: cb on success and NULL on failure
523 struct mei_cl_cb *cb;
529 cb = mei_cl_alloc_cb(cl, length, fop_type, fp);
530 if (!cb)
533 list_add_tail(&cb->list, &cl->dev->ctrl_wr_list);
534 return cb;
542 * @fp: file pointer (matching cb file object), may be NULL
544 * Return: cb on success, NULL if cb is not found
548 struct mei_cl_cb *cb;
552 list_for_each_entry(cb, &cl->rd_completed, list)
553 if (!fp || fp == cb->fp) {
554 ret_cb = cb;
565 * @fp: file pointer (matching cb file object), may be NULL
581 /* free pending and control cb only in final flush */
850 * @cb: callback block
854 static int mei_cl_send_disconnect(struct mei_cl *cl, struct mei_cl_cb *cb)
868 list_move_tail(&cb->list, &dev->ctrl_rd_list);
880 * @cb: callback block.
885 int mei_cl_irq_disconnect(struct mei_cl *cl, struct mei_cl_cb *cb,
901 ret = mei_cl_send_disconnect(cl, cb);
903 list_move_tail(&cb->list, cmpl_list);
919 struct mei_cl_cb *cb;
926 cb = mei_cl_enqueue_ctrl_wr_cb(cl, 0, MEI_FOP_DISCONNECT, NULL);
927 if (!cb) {
933 rets = mei_cl_send_disconnect(cl, cb);
960 mei_io_cb_free(cb);
1027 struct mei_cl_cb *cb;
1031 list_for_each_entry(cb, &dev->ctrl_rd_list, list) {
1032 if (cb->fop_type == MEI_FOP_CONNECT &&
1033 mei_cl_me_id(cl) == mei_cl_me_id(cb->cl))
1044 * @cb: callback block
1048 static int mei_cl_send_connect(struct mei_cl *cl, struct mei_cl_cb *cb)
1062 list_move_tail(&cb->list, &dev->ctrl_rd_list);
1072 * @cb: callback block
1077 int mei_cl_irq_connect(struct mei_cl *cl, struct mei_cl_cb *cb,
1096 rets = mei_cl_send_connect(cl, cb);
1098 list_move_tail(&cb->list, cmpl_list);
1118 struct mei_cl_cb *cb;
1143 cb = mei_cl_enqueue_ctrl_wr_cb(cl, 0, MEI_FOP_CONNECT, fp);
1144 if (!cb) {
1151 rets = mei_cl_send_connect(cl, cb);
1188 mei_io_cb_free(cb);
1393 * @cb: callback block
1396 void mei_cl_add_rd_completed(struct mei_cl *cl, struct mei_cl_cb *cb)
1401 fp = mei_cl_fp_by_vtag(cl, cb->vtag);
1404 mei_io_cb_free(cb);
1407 cb->fp = fp;
1408 mei_cl_reset_read_by_vtag(cl, cb->vtag);
1413 list_add_tail(&cb->list, &cl->rd_completed);
1421 * @cb: callback block
1424 void mei_cl_del_rd_completed(struct mei_cl *cl, struct mei_cl_cb *cb)
1427 mei_io_cb_free(cb);
1465 * @cb: callback block.
1470 int mei_cl_irq_notify(struct mei_cl *cl, struct mei_cl_cb *cb,
1487 request = mei_cl_notify_fop2req(cb->fop_type);
1491 list_move_tail(&cb->list, cmpl_list);
1495 list_move_tail(&cb->list, &dev->ctrl_rd_list);
1514 struct mei_cl_cb *cb;
1539 cb = mei_cl_enqueue_ctrl_wr_cb(cl, 0, fop_type, fp);
1540 if (!cb) {
1550 list_move_tail(&cb->list, &dev->ctrl_rd_list);
1571 mei_io_cb_free(cb);
1666 struct mei_cl_cb *cb;
1691 cb = mei_cl_enqueue_ctrl_wr_cb(cl, length, MEI_FOP_READ, fp);
1692 if (!cb)
1710 list_move_tail(&cb->list, &cl->rd_pending);
1720 mei_io_cb_free(cb);
1736 * @cb: message callback structure
1740 static struct mei_msg_hdr *mei_msg_hdr_init(const struct mei_cl_cb *cb)
1748 if (!cb)
1752 is_vtag = (cb->vtag && cb->buf_idx == 0);
1770 mei_hdr->host_addr = mei_cl_host_addr(cb->cl);
1771 mei_hdr->me_addr = mei_cl_me_id(cb->cl);
1772 mei_hdr->internal = cb->internal;
1781 meta->size += mei_ext_hdr_set_vtag(meta->hdrs, cb->vtag);
1793 * @cb: callback block.
1798 int mei_cl_irq_write(struct mei_cl *cl, struct mei_cl_cb *cb,
1820 buf = &cb->buf;
1822 first_chunk = cb->buf_idx == 0;
1833 buf_len = buf->size - cb->buf_idx;
1834 data = buf->data + cb->buf_idx;
1845 mei_hdr = mei_msg_hdr_init(cb);
1853 mei_hdr->extended, cb->vtag);
1884 mei_dma_ring_write(dev, buf->data + cb->buf_idx, buf_len);
1892 cb->buf_idx += buf_len;
1902 list_move_tail(&cb->list, &dev->write_waiting_list);
1910 list_move_tail(&cb->list, cmpl_list);
1915 * mei_cl_write - submit a write cb to mei device
1919 * @cb: write callback with filled data
1923 ssize_t mei_cl_write(struct mei_cl *cl, struct mei_cl_cb *cb)
1942 if (WARN_ON(!cb))
1947 buf = &cb->buf;
1952 blocking = cb->blocking;
1962 cb->buf_idx = 0;
1970 mei_hdr = mei_msg_hdr_init(cb);
1978 mei_hdr->extended, cb->vtag);
2036 cb->buf_idx = buf_len;
2042 mei_tx_cb_enqueue(cb, &dev->write_waiting_list);
2044 mei_tx_cb_enqueue(cb, &dev->write_list);
2046 cb = NULL;
2072 mei_io_cb_free(cb);
2083 * @cb: callback block.
2085 void mei_cl_complete(struct mei_cl *cl, struct mei_cl_cb *cb)
2089 switch (cb->fop_type) {
2091 mei_tx_cb_dequeue(cb);
2102 mei_cl_add_rd_completed(cl, cb);
2119 mei_io_cb_free(cb);