linux-next: manual merge of the drm-xe tree with the origin tree

[Mark Brown <broonie@kernel.org>]

[-- Attachment #1: Type: text/plain, Size: 11399 bytes --]

Hi all,

Today's linux-next merge of the drm-xe tree got a conflict in:

  drivers/gpu/drm/xe/xe_sysctrl_mailbox.c

between commit:

  f0a4447789ef2 ("drm/xe/sysctrl: Fix mailbox header handling")

from the origin tree and commits:

  5137b39159957 ("drm/xe/sysctrl: Fix mailbox header handling")
  10b59a4c3196c ("drm/xe/sysctrl: Replace FIELD_GET() with REG_FIELD_GET()")

from the drm-xe tree.

I fixed it up (see below) and can carry the fix as necessary. This
is now fixed as far as linux-next is concerned, but any non trivial
conflicts should be mentioned to your upstream maintainer when your tree
is submitted for merging.  You may also want to consider cooperating
with the maintainer of the conflicting tree to minimise any particularly
complex conflicts.

diff --combined drivers/gpu/drm/xe/xe_sysctrl_mailbox.c
index 7701348f0676a,f1a231dfec1e9..0000000000000
--- a/drivers/gpu/drm/xe/xe_sysctrl_mailbox.c
+++ b/drivers/gpu/drm/xe/xe_sysctrl_mailbox.c
@@@ -7,10 -7,12 +7,12 @@@
  #include <linux/cleanup.h>
  #include <linux/minmax.h>
  #include <linux/slab.h>
+ #include <linux/sprintf.h>
  #include <linux/string.h>
  
  #include "regs/xe_sysctrl_regs.h"
  #include "xe_device.h"
+ #include "xe_log.h"
  #include "xe_mmio.h"
  #include "xe_pm.h"
  #include "xe_printk.h"
@@@ -23,41 -25,43 +25,43 @@@ struct xe_sysctrl_mailbox_msg_hdr 
  };
  
  #define XE_SYSCTRL_HDR_GROUP_ID(hdr) \
- 	FIELD_GET(SYSCTRL_HDR_GROUP_ID_MASK, (hdr)->data)
+ 	REG_FIELD_GET(SYSCTRL_HDR_GROUP_ID_MASK, (hdr)->data)
  
  #define XE_SYSCTRL_HDR_COMMAND(hdr) \
- 	FIELD_GET(SYSCTRL_HDR_COMMAND_MASK, (hdr)->data)
+ 	REG_FIELD_GET(SYSCTRL_HDR_COMMAND_MASK, (hdr)->data)
  
  #define XE_SYSCTRL_HDR_IS_RESPONSE(hdr) \
- 	FIELD_GET(SYSCTRL_HDR_IS_RESPONSE, (hdr)->data)
+ 	REG_FIELD_GET(SYSCTRL_HDR_IS_RESPONSE, (hdr)->data)
  
  #define XE_SYSCTRL_HDR_RESULT(hdr) \
- 	FIELD_GET(SYSCTRL_HDR_RESULT_MASK, (hdr)->data)
+ 	REG_FIELD_GET(SYSCTRL_HDR_RESULT_MASK, (hdr)->data)
  
- static bool sysctrl_wait_bit_clear(struct xe_sysctrl *sc, u32 bit_mask,
- 				   unsigned int timeout_ms)
+ static int sysctrl_wait_bit_clear(struct xe_sysctrl *sc, u32 bit_mask,
+ 				  unsigned int timeout_ms, u32 *out_val)
  {
- 	int ret;
- 
- 	ret = xe_mmio_wait32_not(sc->mmio, SYSCTRL_MB_CTRL, bit_mask, bit_mask,
- 				 timeout_ms * 1000, NULL, false);
- 
- 	return ret == 0;
+ 	return xe_mmio_wait32_not(sc->mmio, SYSCTRL_MB_CTRL, bit_mask, bit_mask,
+ 				  timeout_ms * 1000, out_val, false);
  }
  
- static bool sysctrl_wait_bit_set(struct xe_sysctrl *sc, u32 bit_mask,
- 				 unsigned int timeout_ms)
+ static int sysctrl_wait_bit_set(struct xe_sysctrl *sc, u32 bit_mask,
+ 				unsigned int timeout_ms, u32 *out_val)
  {
- 	int ret;
- 
- 	ret = xe_mmio_wait32(sc->mmio, SYSCTRL_MB_CTRL, bit_mask, bit_mask,
- 			     timeout_ms * 1000, NULL, false);
- 
- 	return ret == 0;
+ 	return xe_mmio_wait32(sc->mmio, SYSCTRL_MB_CTRL, bit_mask, bit_mask,
+ 			      timeout_ms * 1000, out_val, false);
  }
  
- static int sysctrl_write_frame(struct xe_sysctrl *sc, const void *frame,
- 			       size_t len)
+ static void sysctrl_mb_ctrl_desc(u32 ctrl_reg, char *buf, size_t size)
+ {
+ 	scnprintf(buf, size, "frame=%u/%u busy=%d resp=%d ctrl=%#010x",
+ 		  REG_FIELD_GET(SYSCTRL_FRAME_CURRENT_MASK, ctrl_reg),
+ 		  REG_FIELD_GET(SYSCTRL_FRAME_TOTAL_MASK, ctrl_reg),
+ 		  !!(ctrl_reg & SYSCTRL_MB_CTRL_RUN_BUSY),
+ 		  !!(ctrl_reg & SYSCTRL_MB_CTRL_RUN_BUSY_OUT),
+ 		  ctrl_reg);
+ }
+ 
+ static void sysctrl_write_frame(struct xe_sysctrl *sc, const void *frame,
+ 				size_t len)
  {
  	static const struct xe_reg regs[] = {
  		SYSCTRL_MB_DATA0, SYSCTRL_MB_DATA1, SYSCTRL_MB_DATA2, SYSCTRL_MB_DATA3
@@@ -73,12 -77,10 +77,10 @@@
  
  	for (i = 0; i < dw; i++)
  		xe_mmio_write32(sc->mmio, regs[i], val[i]);
- 
- 	return 0;
  }
  
- static int sysctrl_read_frame(struct xe_sysctrl *sc, void *frame,
- 			      size_t len)
+ static void sysctrl_read_frame(struct xe_sysctrl *sc, void *frame,
+ 			       size_t len)
  {
  	static const struct xe_reg regs[] = {
  		SYSCTRL_MB_DATA0, SYSCTRL_MB_DATA1, SYSCTRL_MB_DATA2, SYSCTRL_MB_DATA3
@@@ -94,8 -96,6 +96,6 @@@
  		val[i] = xe_mmio_read32(sc->mmio, regs[i]);
  
  	memcpy(frame, val, len);
- 
- 	return 0;
  }
  
  static void sysctrl_clear_response(struct xe_sysctrl *sc)
@@@ -114,10 -114,7 +114,7 @@@ static int sysctrl_prepare_command(stru
  
  	xe_assert(xe, command <= SYSCTRL_HDR_COMMAND_MAX);
  
- 	if (data_in_len > XE_SYSCTRL_MB_MAX_MESSAGE_SIZE - sizeof(*hdr)) {
- 		xe_err(xe, "sysctrl: Input data too large: %zu bytes\n", data_in_len);
- 		return -EINVAL;
- 	}
+ 	xe_assert(xe, data_in_len <= XE_SYSCTRL_MB_MAX_MESSAGE_SIZE - sizeof(*hdr));
  
  	size = sizeof(*hdr) + data_in_len;
  
@@@ -126,8 -123,8 +123,8 @@@
  		return -ENOMEM;
  
  	hdr = (struct xe_sysctrl_mailbox_msg_hdr *)buffer;
- 	hdr->data = FIELD_PREP(SYSCTRL_HDR_GROUP_ID_MASK, group_id) |
- 		    FIELD_PREP(SYSCTRL_HDR_COMMAND_MASK, command);
+ 	hdr->data = REG_FIELD_PREP(SYSCTRL_HDR_GROUP_ID_MASK, group_id) |
+ 		    REG_FIELD_PREP(SYSCTRL_HDR_COMMAND_MASK, command);
  
  	if (data_in && data_in_len)
  		memcpy(buffer + sizeof(*hdr), data_in, data_in_len);
@@@ -142,16 -139,24 +139,24 @@@ static int sysctrl_send_frames(struct x
  			       const u8 *mbox_cmd,
  			       size_t cmd_size, unsigned int timeout_ms)
  {
+ 	const struct xe_sysctrl_mailbox_msg_hdr *hdr =
+ 		(const struct xe_sysctrl_mailbox_msg_hdr *)mbox_cmd;
  	struct xe_device *xe = sc_to_xe(sc);
  	u32 ctrl_reg, total_frames, frame;
  	size_t bytes_sent, frame_size;
+ 	char ctrl_desc[48];
  	bool phase;
+ 	int ret;
  
  	total_frames = DIV_ROUND_UP(cmd_size, XE_SYSCTRL_MB_FRAME_SIZE);
  
- 	if (!sysctrl_wait_bit_clear(sc, SYSCTRL_MB_CTRL_RUN_BUSY, timeout_ms)) {
- 		xe_err(xe, "sysctrl: Mailbox busy\n");
- 		return -EBUSY;
+ 	ret = sysctrl_wait_bit_clear(sc, SYSCTRL_MB_CTRL_RUN_BUSY, timeout_ms, &ctrl_reg);
+ 	if (ret) {
+ 		sysctrl_mb_ctrl_desc(ctrl_reg, ctrl_desc, sizeof(ctrl_desc));
+ 		xe_log_err(xe, SYSCTRL, ret, "Mailbox busy %#x.%#x %s\n",
+ 			   XE_SYSCTRL_HDR_GROUP_ID(hdr), XE_SYSCTRL_HDR_COMMAND(hdr),
+ 			   ctrl_desc);
+ 		return ret;
  	}
  
  	ctrl_reg = xe_mmio_read32(sc->mmio, SYSCTRL_MB_CTRL);
@@@ -161,10 -166,7 +166,7 @@@
  	for (frame = 0; frame < total_frames; frame++) {
  		frame_size = min_t(size_t, cmd_size - bytes_sent, XE_SYSCTRL_MB_FRAME_SIZE);
  
- 		if (sysctrl_write_frame(sc, mbox_cmd + bytes_sent, frame_size)) {
- 			xe_err(xe, "sysctrl: Failed to write frame %u\n", frame);
- 			return -EIO;
- 		}
+ 		sysctrl_write_frame(sc, mbox_cmd + bytes_sent, frame_size);
  
  		ctrl_reg = SYSCTRL_MB_CTRL_RUN_BUSY |
  			   REG_FIELD_PREP(SYSCTRL_FRAME_CURRENT_MASK, frame) |
@@@ -174,9 -176,13 +176,13 @@@
  
  		xe_mmio_write32(sc->mmio, SYSCTRL_MB_CTRL, ctrl_reg);
  
- 		if (!sysctrl_wait_bit_clear(sc, SYSCTRL_MB_CTRL_RUN_BUSY, timeout_ms)) {
- 			xe_err(xe, "sysctrl: Frame %u acknowledgment timeout\n", frame);
- 			return -ETIMEDOUT;
+ 		ret = sysctrl_wait_bit_clear(sc, SYSCTRL_MB_CTRL_RUN_BUSY, timeout_ms, &ctrl_reg);
+ 		if (ret) {
+ 			sysctrl_mb_ctrl_desc(ctrl_reg, ctrl_desc, sizeof(ctrl_desc));
+ 			xe_log_err(xe, SYSCTRL, ret, "Frame acknowledgment timeout %#x.%#x %s\n",
+ 				   XE_SYSCTRL_HDR_GROUP_ID(hdr), XE_SYSCTRL_HDR_COMMAND(hdr),
+ 				   ctrl_desc);
+ 			return ret;
  		}
  
  		bytes_sent += frame_size;
@@@ -185,27 -191,30 +191,30 @@@
  	return 0;
  }
  
- static int sysctrl_process_frame(struct xe_sysctrl *sc, void *out,
- 				 size_t frame_size, unsigned int timeout_ms,
+ static int sysctrl_process_frame(struct xe_sysctrl *sc,
+ 				 const struct xe_sysctrl_mailbox_msg_hdr *req,
+ 				 void *out, size_t frame_size, unsigned int timeout_ms,
  				 bool *done)
  {
  	u32 curr_frame, total_frames, ctrl_reg;
  	struct xe_device *xe = sc_to_xe(sc);
+ 	char ctrl_desc[48];
  	int ret;
  
- 	if (!sysctrl_wait_bit_set(sc, SYSCTRL_MB_CTRL_RUN_BUSY_OUT, timeout_ms)) {
- 		xe_err(xe, "sysctrl: Response frame timeout\n");
- 		return -ETIMEDOUT;
+ 	ret = sysctrl_wait_bit_set(sc, SYSCTRL_MB_CTRL_RUN_BUSY_OUT, timeout_ms, &ctrl_reg);
+ 	if (ret) {
+ 		sysctrl_mb_ctrl_desc(ctrl_reg, ctrl_desc, sizeof(ctrl_desc));
+ 		xe_log_err(xe, SYSCTRL, ret, "Response frame timeout %#x.%#x %s\n",
+ 			   XE_SYSCTRL_HDR_GROUP_ID(req), XE_SYSCTRL_HDR_COMMAND(req),
+ 			   ctrl_desc);
+ 		return ret;
  	}
  
  	ctrl_reg = xe_mmio_read32(sc->mmio, SYSCTRL_MB_CTRL);
- 	total_frames = FIELD_GET(SYSCTRL_FRAME_TOTAL_MASK, ctrl_reg);
- 	curr_frame = FIELD_GET(SYSCTRL_FRAME_CURRENT_MASK, ctrl_reg);
- 
- 	ret = sysctrl_read_frame(sc, out, frame_size);
- 	if (ret)
- 		return ret;
+ 	total_frames = REG_FIELD_GET(SYSCTRL_FRAME_TOTAL_MASK, ctrl_reg);
+ 	curr_frame = REG_FIELD_GET(SYSCTRL_FRAME_CURRENT_MASK, ctrl_reg);
  
+ 	sysctrl_read_frame(sc, out, frame_size);
  	sysctrl_clear_response(sc);
  
  	if (curr_frame == total_frames)
@@@ -235,7 -244,7 +244,7 @@@ static int sysctrl_receive_frames(struc
  	while (!done && remain) {
  		frame_size = min_t(size_t, remain, XE_SYSCTRL_MB_FRAME_SIZE);
  
- 		ret = sysctrl_process_frame(sc, out, frame_size, timeout_ms,
+ 		ret = sysctrl_process_frame(sc, req, out, frame_size, timeout_ms,
  					    &done);
  		if (ret)
  			return ret;
@@@ -249,13 -258,16 +258,16 @@@
  	if (!XE_SYSCTRL_HDR_IS_RESPONSE(hdr) ||
  	    XE_SYSCTRL_HDR_GROUP_ID(hdr) != XE_SYSCTRL_HDR_GROUP_ID(req) ||
  	    XE_SYSCTRL_HDR_COMMAND(hdr) != XE_SYSCTRL_HDR_COMMAND(req)) {
- 		xe_err(xe, "sysctrl: Response header mismatch\n");
+ 		xe_log_err(xe, SYSCTRL, -EPROTO,
+ 			   "Response header mismatch: %#x != %#x\n",
+ 			   hdr->data, req->data);
  		return -EPROTO;
  	}
  
  	if (XE_SYSCTRL_HDR_RESULT(hdr) != 0) {
- 		xe_err(xe, "sysctrl: Firmware error: 0x%02lx\n",
- 		       XE_SYSCTRL_HDR_RESULT(hdr));
+ 		xe_log_err(xe, SYSCTRL, -EIO, "Firmware error: %#04x %#x.%#x\n",
+ 			   XE_SYSCTRL_HDR_RESULT(hdr),
+ 			   XE_SYSCTRL_HDR_GROUP_ID(req), XE_SYSCTRL_HDR_COMMAND(req));
  		return -EIO;
  	}
  
@@@ -311,8 -323,8 +323,8 @@@ void xe_sysctrl_create_command(struct x
  {
  	struct xe_sysctrl_app_msg_hdr header = {0};
  
- 	header.data = FIELD_PREP(APP_HDR_GROUP_ID_MASK, group_id) |
- 		      FIELD_PREP(APP_HDR_COMMAND_MASK, cmd_id);
+ 	header.data = REG_FIELD_PREP(APP_HDR_GROUP_ID_MASK, group_id) |
+ 		      REG_FIELD_PREP(APP_HDR_COMMAND_MASK, cmd_id);
  
  	command->header = header;
  	command->data_in = request;
@@@ -372,7 -384,8 +384,8 @@@ int xe_sysctrl_send_command(struct xe_s
  				      cmd->data_in, cmd->data_in_len,
  				      &mbox_cmd, &cmd_size);
  	if (ret) {
- 		xe_err(xe, "sysctrl: Failed to prepare command: %pe\n", ERR_PTR(ret));
+ 		xe_log_err(xe, SYSCTRL, ret, "Failed to prepare command %#x.%#x\n",
+ 			   group_id, command_code);
  		return ret;
  	}
  
@@@ -382,7 -395,8 +395,8 @@@
  				   cmd->data_out, cmd->data_out_len, rdata_len,
  				   timeout_ms);
  	if (ret)
- 		xe_err(xe, "sysctrl: Mailbox command failed: %pe\n", ERR_PTR(ret));
+ 		xe_log_err(xe, SYSCTRL, ret, "Mailbox command failed to send %#x.%#x\n",
+ 			   group_id, command_code);
  
  	kfree(mbox_cmd);
  

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 488 bytes --]