firmware/arm_scmi/raw_mode.c

193  * struct scmi_xfer_raw_waiter  - Structure to describe an xfer to be waited for
197  * @xfer: A reference to the xfer to be waited for
200  *		    pointed at by xfer->async_done.
206 	struct scmi_xfer *xfer;
216  * @msg: A message buffer used to collect a full message grabbed from an xfer.
336 scmi_xfer_raw_waiter_get(struct scmi_raw_mode_info *raw, struct scmi_xfer *xfer,
349 			xfer->async_done = &rw->async_response;
353 		rw->xfer = xfer;
363 	if (rw->xfer) {
364 		rw->xfer->async_done = NULL;
365 		rw->xfer = NULL;
379 	trace_scmi_xfer_response_wait(rw->xfer->transfer_id, rw->xfer->hdr.id,
380 				      rw->xfer->hdr.protocol_id,
381 				      rw->xfer->hdr.seq,
383 				      rw->xfer->hdr.poll_completion);
424  * xfer structure at the end: to do this out of the context of the write/send
427  * Any sent xfer, to be waited for, is timestamped and queued for later
446 		struct scmi_xfer *xfer;
455 		xfer = rw->xfer;
469 		ret = scmi_xfer_raw_wait_for_message_response(cinfo, xfer,
471 		if (!ret && xfer->hdr.status)
472 			ret = scmi_to_linux_errno(xfer->hdr.status);
475 			raw->desc->ops->mark_txdone(rw->cinfo, ret, xfer);
477 		trace_scmi_xfer_end(xfer->transfer_id, xfer->hdr.id,
478 				    xfer->hdr.protocol_id, xfer->hdr.seq, ret);
481 		if (!ret && xfer->async_done) {
484 			if (!wait_for_completion_timeout(xfer->async_done, tmo))
487 					pack_scmi_header(&xfer->hdr));
490 		/* Release waiter and xfer */
491 		scmi_xfer_raw_put(raw->handle, xfer);
507  * scmi_xfer_raw_get_init  - An helper to build a valid xfer from the provided
514  * @p: A pointer to return the initialized Raw xfer.
516  * After an xfer is picked from the TX pool and filled in with the message
517  * content, the xfer is registered as pending with the core in the usual way
532 	struct scmi_xfer *xfer;
544 	xfer = scmi_xfer_raw_get(raw->handle);
545 	if (IS_ERR(xfer)) {
546 		dev_warn(dev, "RAW - Cannot get a free RAW xfer !\n");
547 		return PTR_ERR(xfer);
550 	/* Build xfer from the provided SCMI bare LE message */
552 	unpack_scmi_header(msg_hdr, &xfer->hdr);
553 	xfer->hdr.seq = (u16)MSG_XTRACT_TOKEN(msg_hdr);
555 	xfer->hdr.poll_completion = false;
556 	xfer->hdr.status = SCMI_SUCCESS;
557 	xfer->tx.len = tx_size;
558 	xfer->rx.len = raw->desc->max_msg_size;
560 	memset(xfer->tx.buf, 0x00, raw->desc->max_msg_size);
561 	if (xfer->tx.len)
562 		memcpy(xfer->tx.buf, (u8 *)buf + sizeof(msg_hdr), xfer->tx.len);
563 	*p = xfer;
568 	 * sequence numbers since, in Raw mode, the xfer (and the token) is
572 		ret = scmi_xfer_raw_inflight_register(raw->handle, xfer);
584 			 "RAW - Could NOT register xfer %d in-flight HDR:0x%08X\n",
585 			 xfer->hdr.seq, msg_hdr);
586 		scmi_xfer_raw_put(raw->handle, xfer);
593  * scmi_do_xfer_raw_start  - An helper to send a valid raw xfer
596  * @xfer: The xfer to send
601  * This function send a previously built raw xfer using an appropriate channel
612 				  struct scmi_xfer *xfer, u8 chan_id,
621 		chan_id = xfer->hdr.protocol_id;
623 		xfer->flags |= SCMI_XFER_FLAG_CHAN_SET;
629 	rw = scmi_xfer_raw_waiter_get(raw, xfer, cinfo, async);
637 		xfer->hdr.poll_completion = true;
639 	reinit_completion(&xfer->done);
640 	/* Make sure xfer state update is visible before sending */
641 	smp_store_mb(xfer->state, SCMI_XFER_SENT_OK);
643 	trace_scmi_xfer_begin(xfer->transfer_id, xfer->hdr.id,
644 			      xfer->hdr.protocol_id, xfer->hdr.seq,
645 			      xfer->hdr.poll_completion);
647 	ret = raw->desc->ops->send_message(rw->cinfo, xfer);
654 	trace_scmi_msg_dump(raw->id, cinfo->id, xfer->hdr.protocol_id,
655 			    xfer->hdr.id, "cmnd", xfer->hdr.seq,
656 			    xfer->hdr.status,
657 			    xfer->tx.buf, xfer->tx.len);
681 	struct scmi_xfer *xfer;
683 	ret = scmi_xfer_raw_get_init(raw, buf, len, &xfer);
687 	ret = scmi_do_xfer_raw_start(raw, xfer, chan_id, async);
689 		scmi_xfer_raw_put(raw->handle, xfer);
818 	 * before sending it with a single RAW xfer.
1266 				 struct scmi_xfer *xfer)
1271 	if (!xfer || !msg || !msg_len)
1275 	msg_size = xfer->rx.len + sizeof(u32);
1277 	if (xfer->hdr.type != MSG_TYPE_NOTIFICATION)
1284 	*m = cpu_to_le32(pack_scmi_header(&xfer->hdr));
1285 	if (xfer->hdr.type != MSG_TYPE_NOTIFICATION)
1286 		*++m = cpu_to_le32(xfer->hdr.status);
1288 	memcpy(++m, xfer->rx.buf, xfer->rx.len);
1300  * @xfer: The xfer containing the message to be reported
1306  * xfer into a dedicated scmi_raw_buffer for later consumption by the user.
1308  * This way the caller can free the related xfer immediately afterwards and the
1310  * holding an xfer for too long.
1312 void scmi_raw_message_report(void *r, struct scmi_xfer *xfer,
1322 	if (!raw || (idx == SCMI_RAW_REPLY_QUEUE && !SCMI_XFER_IS_RAW(xfer)))
1327 				  SCMI_XFER_IS_CHAN_SET(xfer) ? chan_id : 0);
1387 	ret = scmi_xfer_raw_collect(rb->msg.buf, &rb->msg.len, xfer);
1389 		dev_warn(dev, "RAW - Cannot collect xfer into buffer !\n");
1399 			       struct scmi_xfer *xfer, u32 msg_hdr)
1402 	unpack_scmi_header(msg_hdr, &xfer->hdr);
1403 	xfer->hdr.seq = MSG_XTRACT_TOKEN(msg_hdr);
1405 	memset(xfer->rx.buf, 0x00, xfer->rx.len);
1407 	raw->desc->ops->fetch_response(cinfo, xfer);
1415  * @cinfo: A reference to the channel to use to retrieve the broken xfer
1417  * @priv: Any private data related to the xfer.
1424  * xfer to be able to save and enqueue the message, since the regular RX error
1431 	struct scmi_xfer xfer;
1437 	xfer.rx.len = raw->desc->max_msg_size;
1438 	xfer.rx.buf = kzalloc(xfer.rx.len, GFP_ATOMIC);
1439 	if (!xfer.rx.buf) {
1449 		smp_store_mb(xfer.priv, priv);
1451 	scmi_xfer_raw_fill(raw, cinfo, &xfer, msg_hdr);
1452 	scmi_raw_message_report(raw, &xfer, SCMI_RAW_ERRS_QUEUE, 0);
1454 	kfree(xfer.rx.buf);