[cocci] Nested macros

[cocci] Nested macros

[Luca Coelho]

Hi,

I've been struggling with a change I want to make, so I hope someone
can help.

Basically I have something like this in the code:

/* regs below are bits 15:0 */
#define _MIPIA_HSYNC_PADDING_COUNT     (_MIPI_MMIO_BASE(dev_priv) + 0xb028)
#define _MIPIC_HSYNC_PADDING_COUNT     (_MIPI_MMIO_BASE(dev_priv) + 0xb828)
#define MIPI_HSYNC_PADDING_COUNT(port) _MMIO_MIPI(port, _MIPIA_HSYNC_PADDING_COUNT, _MIPIC_HSYNC_PADDING_COUNT)

As you can see, these macros assume that the calling functions have a
local called dev_priv, and I want to fix that. 

So, I'm trying to find all users of macros that have this construct. 
My problem is matching the nesting in the macros.

I have tried this:

@macros_noargs@
identifier m;
expression e =~ "dev_priv";
@@
#define m <+...e...+>

@nested_macros@
identifier macros_noargs.m;
identifier nm;
@@
#define nm(...) <+...m...+>

@@
identifier nested_macros.nm;
@@
-nm
+foo

(this last rule is just for testing if anything is matching, obviously)

But the "nested_macros" rule doesn't seem to work.  Does anyone know
how I can solve this?

Thanks!

--
Cheers,
Luca.

Re: [cocci] Checking selected macro calls with SmPL

[Markus Elfring]

> So, I'm trying to find all users of macros that have this construct.

Do you find the following source code search approach helpful?

@display@
expression e;
identifier call;
@@
 (call(
*      dev_priv
      )
  + e
 )


> My problem is matching the nesting in the macros.

Would you like to take any restrictions better into account?

Regards,
Markus

Re: [cocci] Nested macros

[Julia Lawall]

On Fri, 27 Jan 2023, Luca Coelho wrote:

> Hi,
>
> I've been struggling with a change I want to make, so I hope someone
> can help.
>
> Basically I have something like this in the code:
>
> /* regs below are bits 15:0 */
> #define _MIPIA_HSYNC_PADDING_COUNT     (_MIPI_MMIO_BASE(dev_priv) + 0xb028)
> #define _MIPIC_HSYNC_PADDING_COUNT     (_MIPI_MMIO_BASE(dev_priv) + 0xb828)
> #define MIPI_HSYNC_PADDING_COUNT(port) _MMIO_MIPI(port, _MIPIA_HSYNC_PADDING_COUNT, _MIPIC_HSYNC_PADDING_COUNT)
>
> As you can see, these macros assume that the calling functions have a
> local called dev_priv, and I want to fix that.
>
> So, I'm trying to find all users of macros that have this construct.
> My problem is matching the nesting in the macros.
>
> I have tried this:
>
> @macros_noargs@
> identifier m;
> expression e =~ "dev_priv";
> @@
> #define m <+...e...+>
>
> @nested_macros@
> identifier macros_noargs.m;
> identifier nm;
> @@
> #define nm(...) <+...m...+>
>
> @@
> identifier nested_macros.nm;
> @@
> -nm
> +foo
>
> (this last rule is just for testing if anything is matching, obviously)
>
> But the "nested_macros" rule doesn't seem to work.  Does anyone know
> how I can solve this?

I think that it works already.  If you add the following code to the .c
file, then the call gets changed:

int main() {
  MIPI_HSYNC_PADDING_COUNT(12);
}

I think that the problem is that a rule that replaces an identifier by
another doesn't match a macro definition.  Is that actually the precise
thing you want to do?  Or do you want to do something with the uses of the
macro.

If you want to change the definition, you can also add a rule like this:

@@
identifier nested_macros.nm;
identifier list is;
expression e;
@@

-#define nm(is) e
+#define foo(is) e


julia

Re: [cocci] Nested macros

[Luca Coelho]

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

On Fri, 2023-01-27 at 21:52 +0100, Julia Lawall wrote:
> 
> On Fri, 27 Jan 2023, Luca Coelho wrote:
> 
> > Hi,
> > 
> > I've been struggling with a change I want to make, so I hope someone
> > can help.
> > 
> > Basically I have something like this in the code:
> > 
> > /* regs below are bits 15:0 */
> > #define _MIPIA_HSYNC_PADDING_COUNT     (_MIPI_MMIO_BASE(dev_priv) + 0xb028)
> > #define _MIPIC_HSYNC_PADDING_COUNT     (_MIPI_MMIO_BASE(dev_priv) + 0xb828)
> > #define MIPI_HSYNC_PADDING_COUNT(port) _MMIO_MIPI(port, _MIPIA_HSYNC_PADDING_COUNT, _MIPIC_HSYNC_PADDING_COUNT)
> > 
> > As you can see, these macros assume that the calling functions have a
> > local called dev_priv, and I want to fix that.
> > 
> > So, I'm trying to find all users of macros that have this construct.
> > My problem is matching the nesting in the macros.
> > 
> > I have tried this:
> > 
> > @macros_noargs@
> > identifier m;
> > expression e =~ "dev_priv";
> > @@
> > #define m <+...e...+>
> > 
> > @nested_macros@
> > identifier macros_noargs.m;
> > identifier nm;
> > @@
> > #define nm(...) <+...m...+>
> > 
> > @@
> > identifier nested_macros.nm;
> > @@
> > -nm
> > +foo
> > 
> > (this last rule is just for testing if anything is matching, obviously)
> > 
> > But the "nested_macros" rule doesn't seem to work.  Does anyone know
> > how I can solve this?
> 
> I think that it works already.  If you add the following code to the .c
> file, then the call gets changed:
> 
> int main() {
>   MIPI_HSYNC_PADDING_COUNT(12);
> }
> 
> I think that the problem is that a rule that replaces an identifier by
> another doesn't match a macro definition.  Is that actually the precise
> thing you want to do?  Or do you want to do something with the uses of the
> macro.

This is the initial thing I want to do:

@@
identifier nested_macros.nm;
function f;
identifier dev_priv;
expression e;
@@
f(...) {
	...
-	struct drm_i915_private *dev_priv = e;
+	struct drm_i915_private *i915 = e;

	<+...nm(...)...+>
}

And it indeed works with a handcrafted file for testing (attached as
i915_cocci_test.c), but it doesn't work IRL, for instance in the
drivers/gpu/drm/i915/display/vlv_dsi.c file in the kernel (also
attached)...

I would expect there to be a match in the static void
bxt_dsi_get_pipe_config() function...


> If you want to change the definition, you can also add a rule like this:
> 
> @@
> identifier nested_macros.nm;
> identifier list is;
> expression e;
> @@
> 
> -#define nm(is) e
> +#define foo(is) e

This is not what I actually want to do, I just created the simplest
rule I could come up with to actually see the match (and replacement)
happening. 😉

--
Cheers,
Luca.

[-- Attachment #2: i915_cocci_test.c --]
[-- Type: text/x-csrc, Size: 678 bytes --]

struct drm_i915_private {
	int a, b, c;
};

void *bar(int a, int *b, int *c)
{
	return b;
}

void *baz(void *ptr)
{
	return ptr;
}

#define _MIPI_MMIO_BASE(a)	baz(a)
#define _MMIO_MIPI(a, b, c)	bar(a, b, c)

#define _MIPIA_HSYNC_PADDING_COUNT     (_MIPI_MMIO_BASE(dev_priv) + 0xb028)
#define _MIPIC_HSYNC_PADDING_COUNT     (_MIPI_MMIO_BASE(dev_priv) + 0xb828)
#define MIPI_HSYNC_PADDING_COUNT(port) _MMIO_MIPI(port, _MIPIA_HSYNC_PADDING_COUNT, _MIPIC_HSYNC_PADDING_COUNT)

int my_local;


void main(void)
{
	struct drm_i915_private *dev_priv = 0;

	for (int i = 0; i < 10; i++)
		i = i;

	bar(1, MIPI_HSYNC_PADDING_COUNT(1), &my_local);

	for (int j = 0; j < 5; j++)
		j = j;
}

[-- Attachment #3: vlv_dsi.c --]
[-- Type: text/x-csrc, Size: 63454 bytes --]

/*
 * Copyright © 2013 Intel Corporation
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice (including the next
 * paragraph) shall be included in all copies or substantial portions of the
 * Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 *
 * Author: Jani Nikula <jani.nikula@intel.com>
 */

#include <linux/slab.h>

#include <drm/drm_atomic_helper.h>
#include <drm/drm_crtc.h>
#include <drm/drm_edid.h>
#include <drm/drm_mipi_dsi.h>

#include "i915_drv.h"
#include "i915_reg.h"
#include "intel_atomic.h"
#include "intel_backlight.h"
#include "intel_connector.h"
#include "intel_crtc.h"
#include "intel_de.h"
#include "intel_display_types.h"
#include "intel_dsi.h"
#include "intel_dsi_vbt.h"
#include "intel_fifo_underrun.h"
#include "intel_panel.h"
#include "skl_scaler.h"
#include "vlv_dsi.h"
#include "vlv_dsi_pll.h"
#include "vlv_dsi_regs.h"
#include "vlv_sideband.h"

/* return pixels in terms of txbyteclkhs */
static u16 txbyteclkhs(u16 pixels, int bpp, int lane_count,
		       u16 burst_mode_ratio)
{
	return DIV_ROUND_UP(DIV_ROUND_UP(pixels * bpp * burst_mode_ratio,
					 8 * 100), lane_count);
}

/* return pixels equvalent to txbyteclkhs */
static u16 pixels_from_txbyteclkhs(u16 clk_hs, int bpp, int lane_count,
			u16 burst_mode_ratio)
{
	return DIV_ROUND_UP((clk_hs * lane_count * 8 * 100),
						(bpp * burst_mode_ratio));
}

enum mipi_dsi_pixel_format pixel_format_from_register_bits(u32 fmt)
{
	/* It just so happens the VBT matches register contents. */
	switch (fmt) {
	case VID_MODE_FORMAT_RGB888:
		return MIPI_DSI_FMT_RGB888;
	case VID_MODE_FORMAT_RGB666:
		return MIPI_DSI_FMT_RGB666;
	case VID_MODE_FORMAT_RGB666_PACKED:
		return MIPI_DSI_FMT_RGB666_PACKED;
	case VID_MODE_FORMAT_RGB565:
		return MIPI_DSI_FMT_RGB565;
	default:
		MISSING_CASE(fmt);
		return MIPI_DSI_FMT_RGB666;
	}
}

void vlv_dsi_wait_for_fifo_empty(struct intel_dsi *intel_dsi, enum port port)
{
	struct drm_encoder *encoder = &intel_dsi->base.base;
	struct drm_device *dev = encoder->dev;
	struct drm_i915_private *dev_priv = to_i915(dev);
	u32 mask;

	mask = LP_CTRL_FIFO_EMPTY | HS_CTRL_FIFO_EMPTY |
		LP_DATA_FIFO_EMPTY | HS_DATA_FIFO_EMPTY;

	if (intel_de_wait_for_set(dev_priv, MIPI_GEN_FIFO_STAT(port),
				  mask, 100))
		drm_err(&dev_priv->drm, "DPI FIFOs are not empty\n");
}

static void write_data(struct drm_i915_private *dev_priv,
		       i915_reg_t reg,
		       const u8 *data, u32 len)
{
	u32 i, j;

	for (i = 0; i < len; i += 4) {
		u32 val = 0;

		for (j = 0; j < min_t(u32, len - i, 4); j++)
			val |= *data++ << 8 * j;

		intel_de_write(dev_priv, reg, val);
	}
}

static void read_data(struct drm_i915_private *dev_priv,
		      i915_reg_t reg,
		      u8 *data, u32 len)
{
	u32 i, j;

	for (i = 0; i < len; i += 4) {
		u32 val = intel_de_read(dev_priv, reg);

		for (j = 0; j < min_t(u32, len - i, 4); j++)
			*data++ = val >> 8 * j;
	}
}

static ssize_t intel_dsi_host_transfer(struct mipi_dsi_host *host,
				       const struct mipi_dsi_msg *msg)
{
	struct intel_dsi_host *intel_dsi_host = to_intel_dsi_host(host);
	struct drm_device *dev = intel_dsi_host->intel_dsi->base.base.dev;
	struct drm_i915_private *dev_priv = to_i915(dev);
	enum port port = intel_dsi_host->port;
	struct mipi_dsi_packet packet;
	ssize_t ret;
	const u8 *header, *data;
	i915_reg_t data_reg, ctrl_reg;
	u32 data_mask, ctrl_mask;

	ret = mipi_dsi_create_packet(&packet, msg);
	if (ret < 0)
		return ret;

	header = packet.header;
	data = packet.payload;

	if (msg->flags & MIPI_DSI_MSG_USE_LPM) {
		data_reg = MIPI_LP_GEN_DATA(port);
		data_mask = LP_DATA_FIFO_FULL;
		ctrl_reg = MIPI_LP_GEN_CTRL(port);
		ctrl_mask = LP_CTRL_FIFO_FULL;
	} else {
		data_reg = MIPI_HS_GEN_DATA(port);
		data_mask = HS_DATA_FIFO_FULL;
		ctrl_reg = MIPI_HS_GEN_CTRL(port);
		ctrl_mask = HS_CTRL_FIFO_FULL;
	}

	/* note: this is never true for reads */
	if (packet.payload_length) {
		if (intel_de_wait_for_clear(dev_priv, MIPI_GEN_FIFO_STAT(port),
					    data_mask, 50))
			drm_err(&dev_priv->drm,
				"Timeout waiting for HS/LP DATA FIFO !full\n");

		write_data(dev_priv, data_reg, packet.payload,
			   packet.payload_length);
	}

	if (msg->rx_len) {
		intel_de_write(dev_priv, MIPI_INTR_STAT(port),
			       GEN_READ_DATA_AVAIL);
	}

	if (intel_de_wait_for_clear(dev_priv, MIPI_GEN_FIFO_STAT(port),
				    ctrl_mask, 50)) {
		drm_err(&dev_priv->drm,
			"Timeout waiting for HS/LP CTRL FIFO !full\n");
	}

	intel_de_write(dev_priv, ctrl_reg,
		       header[2] << 16 | header[1] << 8 | header[0]);

	/* ->rx_len is set only for reads */
	if (msg->rx_len) {
		data_mask = GEN_READ_DATA_AVAIL;
		if (intel_de_wait_for_set(dev_priv, MIPI_INTR_STAT(port),
					  data_mask, 50))
			drm_err(&dev_priv->drm,
				"Timeout waiting for read data.\n");

		read_data(dev_priv, data_reg, msg->rx_buf, msg->rx_len);
	}

	/* XXX: fix for reads and writes */
	return 4 + packet.payload_length;
}

static int intel_dsi_host_attach(struct mipi_dsi_host *host,
				 struct mipi_dsi_device *dsi)
{
	return 0;
}

static int intel_dsi_host_detach(struct mipi_dsi_host *host,
				 struct mipi_dsi_device *dsi)
{
	return 0;
}

static const struct mipi_dsi_host_ops intel_dsi_host_ops = {
	.attach = intel_dsi_host_attach,
	.detach = intel_dsi_host_detach,
	.transfer = intel_dsi_host_transfer,
};

/*
 * send a video mode command
 *
 * XXX: commands with data in MIPI_DPI_DATA?
 */
static int dpi_send_cmd(struct intel_dsi *intel_dsi, u32 cmd, bool hs,
			enum port port)
{
	struct drm_encoder *encoder = &intel_dsi->base.base;
	struct drm_device *dev = encoder->dev;
	struct drm_i915_private *dev_priv = to_i915(dev);
	u32 mask;

	/* XXX: pipe, hs */
	if (hs)
		cmd &= ~DPI_LP_MODE;
	else
		cmd |= DPI_LP_MODE;

	/* clear bit */
	intel_de_write(dev_priv, MIPI_INTR_STAT(port), SPL_PKT_SENT_INTERRUPT);

	/* XXX: old code skips write if control unchanged */
	if (cmd == intel_de_read(dev_priv, MIPI_DPI_CONTROL(port)))
		drm_dbg_kms(&dev_priv->drm,
			    "Same special packet %02x twice in a row.\n", cmd);

	intel_de_write(dev_priv, MIPI_DPI_CONTROL(port), cmd);

	mask = SPL_PKT_SENT_INTERRUPT;
	if (intel_de_wait_for_set(dev_priv, MIPI_INTR_STAT(port), mask, 100))
		drm_err(&dev_priv->drm,
			"Video mode command 0x%08x send failed.\n", cmd);

	return 0;
}

static void band_gap_reset(struct drm_i915_private *dev_priv)
{
	vlv_flisdsi_get(dev_priv);

	vlv_flisdsi_write(dev_priv, 0x08, 0x0001);
	vlv_flisdsi_write(dev_priv, 0x0F, 0x0005);
	vlv_flisdsi_write(dev_priv, 0x0F, 0x0025);
	udelay(150);
	vlv_flisdsi_write(dev_priv, 0x0F, 0x0000);
	vlv_flisdsi_write(dev_priv, 0x08, 0x0000);

	vlv_flisdsi_put(dev_priv);
}

static int intel_dsi_compute_config(struct intel_encoder *encoder,
				    struct intel_crtc_state *pipe_config,
				    struct drm_connector_state *conn_state)
{
	struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
	struct intel_dsi *intel_dsi = container_of(encoder, struct intel_dsi,
						   base);
	struct intel_connector *intel_connector = intel_dsi->attached_connector;
	struct drm_display_mode *adjusted_mode = &pipe_config->hw.adjusted_mode;
	int ret;

	drm_dbg_kms(&dev_priv->drm, "\n");
	pipe_config->output_format = INTEL_OUTPUT_FORMAT_RGB;

	ret = intel_panel_compute_config(intel_connector, adjusted_mode);
	if (ret)
		return ret;

	ret = intel_panel_fitting(pipe_config, conn_state);
	if (ret)
		return ret;

	if (adjusted_mode->flags & DRM_MODE_FLAG_DBLSCAN)
		return -EINVAL;

	/* DSI uses short packets for sync events, so clear mode flags for DSI */
	adjusted_mode->flags = 0;

	if (intel_dsi->pixel_format == MIPI_DSI_FMT_RGB888)
		pipe_config->pipe_bpp = 24;
	else
		pipe_config->pipe_bpp = 18;

	if (IS_GEMINILAKE(dev_priv) || IS_BROXTON(dev_priv)) {
		/* Enable Frame time stamp based scanline reporting */
		pipe_config->mode_flags |=
			I915_MODE_FLAG_GET_SCANLINE_FROM_TIMESTAMP;

		/* Dual link goes to DSI transcoder A. */
		if (intel_dsi->ports == BIT(PORT_C))
			pipe_config->cpu_transcoder = TRANSCODER_DSI_C;
		else
			pipe_config->cpu_transcoder = TRANSCODER_DSI_A;

		ret = bxt_dsi_pll_compute(encoder, pipe_config);
		if (ret)
			return -EINVAL;
	} else {
		ret = vlv_dsi_pll_compute(encoder, pipe_config);
		if (ret)
			return -EINVAL;
	}

	pipe_config->clock_set = true;

	return 0;
}

static bool glk_dsi_enable_io(struct intel_encoder *encoder)
{
	struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
	struct intel_dsi *intel_dsi = enc_to_intel_dsi(encoder);
	enum port port;
	u32 tmp;
	bool cold_boot = false;

	/* Set the MIPI mode
	 * If MIPI_Mode is off, then writing to LP_Wake bit is not reflecting.
	 * Power ON MIPI IO first and then write into IO reset and LP wake bits
	 */
	for_each_dsi_port(port, intel_dsi->ports) {
		tmp = intel_de_read(dev_priv, MIPI_CTRL(port));
		intel_de_write(dev_priv, MIPI_CTRL(port),
			       tmp | GLK_MIPIIO_ENABLE);
	}

	/* Put the IO into reset */
	tmp = intel_de_read(dev_priv, MIPI_CTRL(PORT_A));
	tmp &= ~GLK_MIPIIO_RESET_RELEASED;
	intel_de_write(dev_priv, MIPI_CTRL(PORT_A), tmp);

	/* Program LP Wake */
	for_each_dsi_port(port, intel_dsi->ports) {
		tmp = intel_de_read(dev_priv, MIPI_CTRL(port));
		if (!(intel_de_read(dev_priv, MIPI_DEVICE_READY(port)) & DEVICE_READY))
			tmp &= ~GLK_LP_WAKE;
		else
			tmp |= GLK_LP_WAKE;
		intel_de_write(dev_priv, MIPI_CTRL(port), tmp);
	}

	/* Wait for Pwr ACK */
	for_each_dsi_port(port, intel_dsi->ports) {
		if (intel_de_wait_for_set(dev_priv, MIPI_CTRL(port),
					  GLK_MIPIIO_PORT_POWERED, 20))
			drm_err(&dev_priv->drm, "MIPIO port is powergated\n");
	}

	/* Check for cold boot scenario */
	for_each_dsi_port(port, intel_dsi->ports) {
		cold_boot |=
			!(intel_de_read(dev_priv, MIPI_DEVICE_READY(port)) & DEVICE_READY);
	}

	return cold_boot;
}

static void glk_dsi_device_ready(struct intel_encoder *encoder)
{
	struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
	struct intel_dsi *intel_dsi = enc_to_intel_dsi(encoder);
	enum port port;
	u32 val;

	/* Wait for MIPI PHY status bit to set */
	for_each_dsi_port(port, intel_dsi->ports) {
		if (intel_de_wait_for_set(dev_priv, MIPI_CTRL(port),
					  GLK_PHY_STATUS_PORT_READY, 20))
			drm_err(&dev_priv->drm, "PHY is not ON\n");
	}

	/* Get IO out of reset */
	val = intel_de_read(dev_priv, MIPI_CTRL(PORT_A));
	intel_de_write(dev_priv, MIPI_CTRL(PORT_A),
		       val | GLK_MIPIIO_RESET_RELEASED);

	/* Get IO out of Low power state*/
	for_each_dsi_port(port, intel_dsi->ports) {
		if (!(intel_de_read(dev_priv, MIPI_DEVICE_READY(port)) & DEVICE_READY)) {
			val = intel_de_read(dev_priv, MIPI_DEVICE_READY(port));
			val &= ~ULPS_STATE_MASK;
			val |= DEVICE_READY;
			intel_de_write(dev_priv, MIPI_DEVICE_READY(port), val);
			usleep_range(10, 15);
		} else {
			/* Enter ULPS */
			val = intel_de_read(dev_priv, MIPI_DEVICE_READY(port));
			val &= ~ULPS_STATE_MASK;
			val |= (ULPS_STATE_ENTER | DEVICE_READY);
			intel_de_write(dev_priv, MIPI_DEVICE_READY(port), val);

			/* Wait for ULPS active */
			if (intel_de_wait_for_clear(dev_priv, MIPI_CTRL(port),
						    GLK_ULPS_NOT_ACTIVE, 20))
				drm_err(&dev_priv->drm, "ULPS not active\n");

			/* Exit ULPS */
			val = intel_de_read(dev_priv, MIPI_DEVICE_READY(port));
			val &= ~ULPS_STATE_MASK;
			val |= (ULPS_STATE_EXIT | DEVICE_READY);
			intel_de_write(dev_priv, MIPI_DEVICE_READY(port), val);

			/* Enter Normal Mode */
			val = intel_de_read(dev_priv, MIPI_DEVICE_READY(port));
			val &= ~ULPS_STATE_MASK;
			val |= (ULPS_STATE_NORMAL_OPERATION | DEVICE_READY);
			intel_de_write(dev_priv, MIPI_DEVICE_READY(port), val);

			val = intel_de_read(dev_priv, MIPI_CTRL(port));
			val &= ~GLK_LP_WAKE;
			intel_de_write(dev_priv, MIPI_CTRL(port), val);
		}
	}

	/* Wait for Stop state */
	for_each_dsi_port(port, intel_dsi->ports) {
		if (intel_de_wait_for_set(dev_priv, MIPI_CTRL(port),
					  GLK_DATA_LANE_STOP_STATE, 20))
			drm_err(&dev_priv->drm,
				"Date lane not in STOP state\n");
	}

	/* Wait for AFE LATCH */
	for_each_dsi_port(port, intel_dsi->ports) {
		if (intel_de_wait_for_set(dev_priv, BXT_MIPI_PORT_CTRL(port),
					  AFE_LATCHOUT, 20))
			drm_err(&dev_priv->drm,
				"D-PHY not entering LP-11 state\n");
	}
}

static void bxt_dsi_device_ready(struct intel_encoder *encoder)
{
	struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
	struct intel_dsi *intel_dsi = enc_to_intel_dsi(encoder);
	enum port port;
	u32 val;

	drm_dbg_kms(&dev_priv->drm, "\n");

	/* Enable MIPI PHY transparent latch */
	for_each_dsi_port(port, intel_dsi->ports) {
		val = intel_de_read(dev_priv, BXT_MIPI_PORT_CTRL(port));
		intel_de_write(dev_priv, BXT_MIPI_PORT_CTRL(port),
			       val | LP_OUTPUT_HOLD);
		usleep_range(2000, 2500);
	}

	/* Clear ULPS and set device ready */
	for_each_dsi_port(port, intel_dsi->ports) {
		val = intel_de_read(dev_priv, MIPI_DEVICE_READY(port));
		val &= ~ULPS_STATE_MASK;
		intel_de_write(dev_priv, MIPI_DEVICE_READY(port), val);
		usleep_range(2000, 2500);
		val |= DEVICE_READY;
		intel_de_write(dev_priv, MIPI_DEVICE_READY(port), val);
	}
}

static void vlv_dsi_device_ready(struct intel_encoder *encoder)
{
	struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
	struct intel_dsi *intel_dsi = enc_to_intel_dsi(encoder);
	enum port port;
	u32 val;

	drm_dbg_kms(&dev_priv->drm, "\n");

	vlv_flisdsi_get(dev_priv);
	/* program rcomp for compliance, reduce from 50 ohms to 45 ohms
	 * needed everytime after power gate */
	vlv_flisdsi_write(dev_priv, 0x04, 0x0004);
	vlv_flisdsi_put(dev_priv);

	/* bandgap reset is needed after everytime we do power gate */
	band_gap_reset(dev_priv);

	for_each_dsi_port(port, intel_dsi->ports) {

		intel_de_write(dev_priv, MIPI_DEVICE_READY(port),
			       ULPS_STATE_ENTER);
		usleep_range(2500, 3000);

		/* Enable MIPI PHY transparent latch
		 * Common bit for both MIPI Port A & MIPI Port C
		 * No similar bit in MIPI Port C reg
		 */
		val = intel_de_read(dev_priv, MIPI_PORT_CTRL(PORT_A));
		intel_de_write(dev_priv, MIPI_PORT_CTRL(PORT_A),
			       val | LP_OUTPUT_HOLD);
		usleep_range(1000, 1500);

		intel_de_write(dev_priv, MIPI_DEVICE_READY(port),
			       ULPS_STATE_EXIT);
		usleep_range(2500, 3000);

		intel_de_write(dev_priv, MIPI_DEVICE_READY(port),
			       DEVICE_READY);
		usleep_range(2500, 3000);
	}
}

static void intel_dsi_device_ready(struct intel_encoder *encoder)
{
	struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);

	if (IS_GEMINILAKE(dev_priv))
		glk_dsi_device_ready(encoder);
	else if (IS_GEMINILAKE(dev_priv) || IS_BROXTON(dev_priv))
		bxt_dsi_device_ready(encoder);
	else
		vlv_dsi_device_ready(encoder);
}

static void glk_dsi_enter_low_power_mode(struct intel_encoder *encoder)
{
	struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
	struct intel_dsi *intel_dsi = enc_to_intel_dsi(encoder);
	enum port port;
	u32 val;

	/* Enter ULPS */
	for_each_dsi_port(port, intel_dsi->ports) {
		val = intel_de_read(dev_priv, MIPI_DEVICE_READY(port));
		val &= ~ULPS_STATE_MASK;
		val |= (ULPS_STATE_ENTER | DEVICE_READY);
		intel_de_write(dev_priv, MIPI_DEVICE_READY(port), val);
	}

	/* Wait for MIPI PHY status bit to unset */
	for_each_dsi_port(port, intel_dsi->ports) {
		if (intel_de_wait_for_clear(dev_priv, MIPI_CTRL(port),
					    GLK_PHY_STATUS_PORT_READY, 20))
			drm_err(&dev_priv->drm, "PHY is not turning OFF\n");
	}

	/* Wait for Pwr ACK bit to unset */
	for_each_dsi_port(port, intel_dsi->ports) {
		if (intel_de_wait_for_clear(dev_priv, MIPI_CTRL(port),
					    GLK_MIPIIO_PORT_POWERED, 20))
			drm_err(&dev_priv->drm,
				"MIPI IO Port is not powergated\n");
	}
}

static void glk_dsi_disable_mipi_io(struct intel_encoder *encoder)
{
	struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
	struct intel_dsi *intel_dsi = enc_to_intel_dsi(encoder);
	enum port port;
	u32 tmp;

	/* Put the IO into reset */
	tmp = intel_de_read(dev_priv, MIPI_CTRL(PORT_A));
	tmp &= ~GLK_MIPIIO_RESET_RELEASED;
	intel_de_write(dev_priv, MIPI_CTRL(PORT_A), tmp);

	/* Wait for MIPI PHY status bit to unset */
	for_each_dsi_port(port, intel_dsi->ports) {
		if (intel_de_wait_for_clear(dev_priv, MIPI_CTRL(port),
					    GLK_PHY_STATUS_PORT_READY, 20))
			drm_err(&dev_priv->drm, "PHY is not turning OFF\n");
	}

	/* Clear MIPI mode */
	for_each_dsi_port(port, intel_dsi->ports) {
		tmp = intel_de_read(dev_priv, MIPI_CTRL(port));
		tmp &= ~GLK_MIPIIO_ENABLE;
		intel_de_write(dev_priv, MIPI_CTRL(port), tmp);
	}
}

static void glk_dsi_clear_device_ready(struct intel_encoder *encoder)
{
	glk_dsi_enter_low_power_mode(encoder);
	glk_dsi_disable_mipi_io(encoder);
}

static void vlv_dsi_clear_device_ready(struct intel_encoder *encoder)
{
	struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
	struct intel_dsi *intel_dsi = enc_to_intel_dsi(encoder);
	enum port port;

	drm_dbg_kms(&dev_priv->drm, "\n");
	for_each_dsi_port(port, intel_dsi->ports) {
		/* Common bit for both MIPI Port A & MIPI Port C on VLV/CHV */
		i915_reg_t port_ctrl = IS_GEMINILAKE(dev_priv) || IS_BROXTON(dev_priv) ?
			BXT_MIPI_PORT_CTRL(port) : MIPI_PORT_CTRL(PORT_A);
		u32 val;

		intel_de_write(dev_priv, MIPI_DEVICE_READY(port),
			       DEVICE_READY | ULPS_STATE_ENTER);
		usleep_range(2000, 2500);

		intel_de_write(dev_priv, MIPI_DEVICE_READY(port),
			       DEVICE_READY | ULPS_STATE_EXIT);
		usleep_range(2000, 2500);

		intel_de_write(dev_priv, MIPI_DEVICE_READY(port),
			       DEVICE_READY | ULPS_STATE_ENTER);
		usleep_range(2000, 2500);

		/*
		 * On VLV/CHV, wait till Clock lanes are in LP-00 state for MIPI
		 * Port A only. MIPI Port C has no similar bit for checking.
		 */
		if ((IS_GEMINILAKE(dev_priv) || IS_BROXTON(dev_priv) || port == PORT_A) &&
		    intel_de_wait_for_clear(dev_priv, port_ctrl,
					    AFE_LATCHOUT, 30))
			drm_err(&dev_priv->drm, "DSI LP not going Low\n");

		/* Disable MIPI PHY transparent latch */
		val = intel_de_read(dev_priv, port_ctrl);
		intel_de_write(dev_priv, port_ctrl, val & ~LP_OUTPUT_HOLD);
		usleep_range(1000, 1500);

		intel_de_write(dev_priv, MIPI_DEVICE_READY(port), 0x00);
		usleep_range(2000, 2500);
	}
}

static void intel_dsi_port_enable(struct intel_encoder *encoder,
				  const struct intel_crtc_state *crtc_state)
{
	struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
	struct intel_crtc *crtc = to_intel_crtc(crtc_state->uapi.crtc);
	struct intel_dsi *intel_dsi = enc_to_intel_dsi(encoder);
	enum port port;

	if (intel_dsi->dual_link == DSI_DUAL_LINK_FRONT_BACK) {
		u32 temp;
		if (IS_GEMINILAKE(dev_priv) || IS_BROXTON(dev_priv)) {
			for_each_dsi_port(port, intel_dsi->ports) {
				temp = intel_de_read(dev_priv,
						     MIPI_CTRL(port));
				temp &= ~BXT_PIXEL_OVERLAP_CNT_MASK |
					intel_dsi->pixel_overlap <<
					BXT_PIXEL_OVERLAP_CNT_SHIFT;
				intel_de_write(dev_priv, MIPI_CTRL(port),
					       temp);
			}
		} else {
			temp = intel_de_read(dev_priv, VLV_CHICKEN_3);
			temp &= ~PIXEL_OVERLAP_CNT_MASK |
					intel_dsi->pixel_overlap <<
					PIXEL_OVERLAP_CNT_SHIFT;
			intel_de_write(dev_priv, VLV_CHICKEN_3, temp);
		}
	}

	for_each_dsi_port(port, intel_dsi->ports) {
		i915_reg_t port_ctrl = IS_GEMINILAKE(dev_priv) || IS_BROXTON(dev_priv) ?
			BXT_MIPI_PORT_CTRL(port) : MIPI_PORT_CTRL(port);
		u32 temp;

		temp = intel_de_read(dev_priv, port_ctrl);

		temp &= ~LANE_CONFIGURATION_MASK;
		temp &= ~DUAL_LINK_MODE_MASK;

		if (intel_dsi->ports == (BIT(PORT_A) | BIT(PORT_C))) {
			temp |= (intel_dsi->dual_link - 1)
						<< DUAL_LINK_MODE_SHIFT;
			if (IS_BROXTON(dev_priv))
				temp |= LANE_CONFIGURATION_DUAL_LINK_A;
			else
				temp |= crtc->pipe ?
					LANE_CONFIGURATION_DUAL_LINK_B :
					LANE_CONFIGURATION_DUAL_LINK_A;
		}

		if (intel_dsi->pixel_format != MIPI_DSI_FMT_RGB888)
			temp |= DITHERING_ENABLE;

		/* assert ip_tg_enable signal */
		intel_de_write(dev_priv, port_ctrl, temp | DPI_ENABLE);
		intel_de_posting_read(dev_priv, port_ctrl);
	}
}

static void intel_dsi_port_disable(struct intel_encoder *encoder)
{
	struct drm_device *dev = encoder->base.dev;
	struct drm_i915_private *dev_priv = to_i915(dev);
	struct intel_dsi *intel_dsi = enc_to_intel_dsi(encoder);
	enum port port;

	for_each_dsi_port(port, intel_dsi->ports) {
		i915_reg_t port_ctrl = IS_GEMINILAKE(dev_priv) || IS_BROXTON(dev_priv) ?
			BXT_MIPI_PORT_CTRL(port) : MIPI_PORT_CTRL(port);
		u32 temp;

		/* de-assert ip_tg_enable signal */
		temp = intel_de_read(dev_priv, port_ctrl);
		intel_de_write(dev_priv, port_ctrl, temp & ~DPI_ENABLE);
		intel_de_posting_read(dev_priv, port_ctrl);
	}
}

static void intel_dsi_wait_panel_power_cycle(struct intel_dsi *intel_dsi)
{
	ktime_t panel_power_on_time;
	s64 panel_power_off_duration;

	panel_power_on_time = ktime_get_boottime();
	panel_power_off_duration = ktime_ms_delta(panel_power_on_time,
						  intel_dsi->panel_power_off_time);

	if (panel_power_off_duration < (s64)intel_dsi->panel_pwr_cycle_delay)
		msleep(intel_dsi->panel_pwr_cycle_delay - panel_power_off_duration);
}

static void intel_dsi_prepare(struct intel_encoder *intel_encoder,
			      const struct intel_crtc_state *pipe_config);
static void intel_dsi_unprepare(struct intel_encoder *encoder);

/*
 * Panel enable/disable sequences from the VBT spec.
 *
 * Note the spec has AssertReset / DeassertReset swapped from their
 * usual naming. We use the normal names to avoid confusion (so below
 * they are swapped compared to the spec).
 *
 * Steps starting with MIPI refer to VBT sequences, note that for v2
 * VBTs several steps which have a VBT in v2 are expected to be handled
 * directly by the driver, by directly driving gpios for example.
 *
 * v2 video mode seq         v3 video mode seq         command mode seq
 * - power on                - MIPIPanelPowerOn        - power on
 * - wait t1+t2                                        - wait t1+t2
 * - MIPIDeassertResetPin    - MIPIDeassertResetPin    - MIPIDeassertResetPin
 * - io lines to lp-11       - io lines to lp-11       - io lines to lp-11
 * - MIPISendInitialDcsCmds  - MIPISendInitialDcsCmds  - MIPISendInitialDcsCmds
 *                                                     - MIPITearOn
 *                                                     - MIPIDisplayOn
 * - turn on DPI             - turn on DPI             - set pipe to dsr mode
 * - MIPIDisplayOn           - MIPIDisplayOn
 * - wait t5                                           - wait t5
 * - backlight on            - MIPIBacklightOn         - backlight on
 * ...                       ...                       ... issue mem cmds ...
 * - backlight off           - MIPIBacklightOff        - backlight off
 * - wait t6                                           - wait t6
 * - MIPIDisplayOff
 * - turn off DPI            - turn off DPI            - disable pipe dsr mode
 *                                                     - MIPITearOff
 *                           - MIPIDisplayOff          - MIPIDisplayOff
 * - io lines to lp-00       - io lines to lp-00       - io lines to lp-00
 * - MIPIAssertResetPin      - MIPIAssertResetPin      - MIPIAssertResetPin
 * - wait t3                                           - wait t3
 * - power off               - MIPIPanelPowerOff       - power off
 * - wait t4                                           - wait t4
 */

/*
 * DSI port enable has to be done before pipe and plane enable, so we do it in
 * the pre_enable hook instead of the enable hook.
 */
static void intel_dsi_pre_enable(struct intel_atomic_state *state,
				 struct intel_encoder *encoder,
				 const struct intel_crtc_state *pipe_config,
				 const struct drm_connector_state *conn_state)
{
	struct intel_dsi *intel_dsi = enc_to_intel_dsi(encoder);
	struct intel_crtc *crtc = to_intel_crtc(pipe_config->uapi.crtc);
	struct intel_connector *connector = to_intel_connector(conn_state->connector);
	struct drm_i915_private *dev_priv = to_i915(crtc->base.dev);
	enum pipe pipe = crtc->pipe;
	enum port port;
	u32 val;
	bool glk_cold_boot = false;

	drm_dbg_kms(&dev_priv->drm, "\n");

	intel_dsi_wait_panel_power_cycle(intel_dsi);

	intel_set_cpu_fifo_underrun_reporting(dev_priv, pipe, true);

	/*
	 * The BIOS may leave the PLL in a wonky state where it doesn't
	 * lock. It needs to be fully powered down to fix it.
	 */
	if (IS_GEMINILAKE(dev_priv) || IS_BROXTON(dev_priv)) {
		bxt_dsi_pll_disable(encoder);
		bxt_dsi_pll_enable(encoder, pipe_config);
	} else {
		vlv_dsi_pll_disable(encoder);
		vlv_dsi_pll_enable(encoder, pipe_config);
	}

	if (IS_BROXTON(dev_priv)) {
		/* Add MIPI IO reset programming for modeset */
		val = intel_de_read(dev_priv, BXT_P_CR_GT_DISP_PWRON);
		intel_de_write(dev_priv, BXT_P_CR_GT_DISP_PWRON,
			       val | MIPIO_RST_CTRL);

		/* Power up DSI regulator */
		intel_de_write(dev_priv, BXT_P_DSI_REGULATOR_CFG, STAP_SELECT);
		intel_de_write(dev_priv, BXT_P_DSI_REGULATOR_TX_CTRL, 0);
	}

	if (IS_VALLEYVIEW(dev_priv) || IS_CHERRYVIEW(dev_priv)) {
		u32 val;

		/* Disable DPOunit clock gating, can stall pipe */
		val = intel_de_read(dev_priv, DSPCLK_GATE_D(dev_priv));
		val |= DPOUNIT_CLOCK_GATE_DISABLE;
		intel_de_write(dev_priv, DSPCLK_GATE_D(dev_priv), val);
	}

	if (!IS_GEMINILAKE(dev_priv))
		intel_dsi_prepare(encoder, pipe_config);

	intel_dsi_vbt_exec_sequence(intel_dsi, MIPI_SEQ_POWER_ON);

	/*
	 * Give the panel time to power-on and then deassert its reset.
	 * Depending on the VBT MIPI sequences version the deassert-seq
	 * may contain the necessary delay, intel_dsi_msleep() will skip
	 * the delay in that case. If there is no deassert-seq, then an
	 * unconditional msleep is used to give the panel time to power-on.
	 */
	if (connector->panel.vbt.dsi.sequence[MIPI_SEQ_DEASSERT_RESET]) {
		intel_dsi_msleep(intel_dsi, intel_dsi->panel_on_delay);
		intel_dsi_vbt_exec_sequence(intel_dsi, MIPI_SEQ_DEASSERT_RESET);
	} else {
		msleep(intel_dsi->panel_on_delay);
	}

	if (IS_GEMINILAKE(dev_priv)) {
		glk_cold_boot = glk_dsi_enable_io(encoder);

		/* Prepare port in cold boot(s3/s4) scenario */
		if (glk_cold_boot)
			intel_dsi_prepare(encoder, pipe_config);
	}

	/* Put device in ready state (LP-11) */
	intel_dsi_device_ready(encoder);

	/* Prepare port in normal boot scenario */
	if (IS_GEMINILAKE(dev_priv) && !glk_cold_boot)
		intel_dsi_prepare(encoder, pipe_config);

	/* Send initialization commands in LP mode */
	intel_dsi_vbt_exec_sequence(intel_dsi, MIPI_SEQ_INIT_OTP);

	/*
	 * Enable port in pre-enable phase itself because as per hw team
	 * recommendation, port should be enabled before plane & pipe
	 */
	if (is_cmd_mode(intel_dsi)) {
		for_each_dsi_port(port, intel_dsi->ports)
			intel_de_write(dev_priv,
				       MIPI_MAX_RETURN_PKT_SIZE(port), 8 * 4);
		intel_dsi_vbt_exec_sequence(intel_dsi, MIPI_SEQ_TEAR_ON);
		intel_dsi_vbt_exec_sequence(intel_dsi, MIPI_SEQ_DISPLAY_ON);
	} else {
		msleep(20); /* XXX */
		for_each_dsi_port(port, intel_dsi->ports)
			dpi_send_cmd(intel_dsi, TURN_ON, false, port);
		intel_dsi_msleep(intel_dsi, 100);

		intel_dsi_vbt_exec_sequence(intel_dsi, MIPI_SEQ_DISPLAY_ON);

		intel_dsi_port_enable(encoder, pipe_config);
	}

	intel_backlight_enable(pipe_config, conn_state);
	intel_dsi_vbt_exec_sequence(intel_dsi, MIPI_SEQ_BACKLIGHT_ON);
}

static void bxt_dsi_enable(struct intel_atomic_state *state,
			   struct intel_encoder *encoder,
			   const struct intel_crtc_state *crtc_state,
			   const struct drm_connector_state *conn_state)
{
	drm_WARN_ON(state->base.dev, crtc_state->has_pch_encoder);

	intel_crtc_vblank_on(crtc_state);
}

/*
 * DSI port disable has to be done after pipe and plane disable, so we do it in
 * the post_disable hook.
 */
static void intel_dsi_disable(struct intel_atomic_state *state,
			      struct intel_encoder *encoder,
			      const struct intel_crtc_state *old_crtc_state,
			      const struct drm_connector_state *old_conn_state)
{
	struct drm_i915_private *i915 = to_i915(encoder->base.dev);
	struct intel_dsi *intel_dsi = enc_to_intel_dsi(encoder);
	enum port port;

	drm_dbg_kms(&i915->drm, "\n");

	intel_dsi_vbt_exec_sequence(intel_dsi, MIPI_SEQ_BACKLIGHT_OFF);
	intel_backlight_disable(old_conn_state);

	/*
	 * According to the spec we should send SHUTDOWN before
	 * MIPI_SEQ_DISPLAY_OFF only for v3+ VBTs, but field testing
	 * has shown that the v3 sequence works for v2 VBTs too
	 */
	if (is_vid_mode(intel_dsi)) {
		/* Send Shutdown command to the panel in LP mode */
		for_each_dsi_port(port, intel_dsi->ports)
			dpi_send_cmd(intel_dsi, SHUTDOWN, false, port);
		msleep(10);
	}
}

static void intel_dsi_clear_device_ready(struct intel_encoder *encoder)
{
	struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);

	if (IS_GEMINILAKE(dev_priv))
		glk_dsi_clear_device_ready(encoder);
	else
		vlv_dsi_clear_device_ready(encoder);
}

static void intel_dsi_post_disable(struct intel_atomic_state *state,
				   struct intel_encoder *encoder,
				   const struct intel_crtc_state *old_crtc_state,
				   const struct drm_connector_state *old_conn_state)
{
	struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
	struct intel_dsi *intel_dsi = enc_to_intel_dsi(encoder);
	enum port port;
	u32 val;

	drm_dbg_kms(&dev_priv->drm, "\n");

	if (IS_GEMINILAKE(dev_priv) || IS_BROXTON(dev_priv)) {
		intel_crtc_vblank_off(old_crtc_state);

		skl_scaler_disable(old_crtc_state);
	}

	if (is_vid_mode(intel_dsi)) {
		for_each_dsi_port(port, intel_dsi->ports)
			vlv_dsi_wait_for_fifo_empty(intel_dsi, port);

		intel_dsi_port_disable(encoder);
		usleep_range(2000, 5000);
	}

	intel_dsi_unprepare(encoder);

	/*
	 * if disable packets are sent before sending shutdown packet then in
	 * some next enable sequence send turn on packet error is observed
	 */
	if (is_cmd_mode(intel_dsi))
		intel_dsi_vbt_exec_sequence(intel_dsi, MIPI_SEQ_TEAR_OFF);
	intel_dsi_vbt_exec_sequence(intel_dsi, MIPI_SEQ_DISPLAY_OFF);

	/* Transition to LP-00 */
	intel_dsi_clear_device_ready(encoder);

	if (IS_BROXTON(dev_priv)) {
		/* Power down DSI regulator to save power */
		intel_de_write(dev_priv, BXT_P_DSI_REGULATOR_CFG, STAP_SELECT);
		intel_de_write(dev_priv, BXT_P_DSI_REGULATOR_TX_CTRL,
			       HS_IO_CTRL_SELECT);

		/* Add MIPI IO reset programming for modeset */
		val = intel_de_read(dev_priv, BXT_P_CR_GT_DISP_PWRON);
		intel_de_write(dev_priv, BXT_P_CR_GT_DISP_PWRON,
			       val & ~MIPIO_RST_CTRL);
	}

	if (IS_GEMINILAKE(dev_priv) || IS_BROXTON(dev_priv)) {
		bxt_dsi_pll_disable(encoder);
	} else {
		u32 val;

		vlv_dsi_pll_disable(encoder);

		val = intel_de_read(dev_priv, DSPCLK_GATE_D(dev_priv));
		val &= ~DPOUNIT_CLOCK_GATE_DISABLE;
		intel_de_write(dev_priv, DSPCLK_GATE_D(dev_priv), val);
	}

	/* Assert reset */
	intel_dsi_vbt_exec_sequence(intel_dsi, MIPI_SEQ_ASSERT_RESET);

	intel_dsi_msleep(intel_dsi, intel_dsi->panel_off_delay);
	intel_dsi_vbt_exec_sequence(intel_dsi, MIPI_SEQ_POWER_OFF);

	intel_dsi->panel_power_off_time = ktime_get_boottime();
}

static void intel_dsi_shutdown(struct intel_encoder *encoder)
{
	struct intel_dsi *intel_dsi = enc_to_intel_dsi(encoder);

	intel_dsi_wait_panel_power_cycle(intel_dsi);
}

static bool intel_dsi_get_hw_state(struct intel_encoder *encoder,
				   enum pipe *pipe)
{
	struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
	struct intel_dsi *intel_dsi = enc_to_intel_dsi(encoder);
	intel_wakeref_t wakeref;
	enum port port;
	bool active = false;

	drm_dbg_kms(&dev_priv->drm, "\n");

	wakeref = intel_display_power_get_if_enabled(dev_priv,
						     encoder->power_domain);
	if (!wakeref)
		return false;

	/*
	 * On Broxton the PLL needs to be enabled with a valid divider
	 * configuration, otherwise accessing DSI registers will hang the
	 * machine. See BSpec North Display Engine registers/MIPI[BXT].
	 */
	if ((IS_GEMINILAKE(dev_priv) || IS_BROXTON(dev_priv)) &&
	    !bxt_dsi_pll_is_enabled(dev_priv))
		goto out_put_power;

	/* XXX: this only works for one DSI output */
	for_each_dsi_port(port, intel_dsi->ports) {
		i915_reg_t ctrl_reg = IS_GEMINILAKE(dev_priv) || IS_BROXTON(dev_priv) ?
			BXT_MIPI_PORT_CTRL(port) : MIPI_PORT_CTRL(port);
		bool enabled = intel_de_read(dev_priv, ctrl_reg) & DPI_ENABLE;

		/*
		 * Due to some hardware limitations on VLV/CHV, the DPI enable
		 * bit in port C control register does not get set. As a
		 * workaround, check pipe B conf instead.
		 */
		if ((IS_VALLEYVIEW(dev_priv) || IS_CHERRYVIEW(dev_priv)) &&
		    port == PORT_C)
			enabled = intel_de_read(dev_priv, PIPECONF(PIPE_B)) & PIPECONF_ENABLE;

		/* Try command mode if video mode not enabled */
		if (!enabled) {
			u32 tmp = intel_de_read(dev_priv,
						MIPI_DSI_FUNC_PRG(port));
			enabled = tmp & CMD_MODE_DATA_WIDTH_MASK;
		}

		if (!enabled)
			continue;

		if (!(intel_de_read(dev_priv, MIPI_DEVICE_READY(port)) & DEVICE_READY))
			continue;

		if (IS_GEMINILAKE(dev_priv) || IS_BROXTON(dev_priv)) {
			u32 tmp = intel_de_read(dev_priv, MIPI_CTRL(port));
			tmp &= BXT_PIPE_SELECT_MASK;
			tmp >>= BXT_PIPE_SELECT_SHIFT;

			if (drm_WARN_ON(&dev_priv->drm, tmp > PIPE_C))
				continue;

			*pipe = tmp;
		} else {
			*pipe = port == PORT_A ? PIPE_A : PIPE_B;
		}

		active = true;
		break;
	}

out_put_power:
	intel_display_power_put(dev_priv, encoder->power_domain, wakeref);

	return active;
}

static void bxt_dsi_get_pipe_config(struct intel_encoder *encoder,
				    struct intel_crtc_state *pipe_config)
{
	struct drm_device *dev = encoder->base.dev;
	struct drm_i915_private *dev_priv = to_i915(dev);
	struct drm_display_mode *adjusted_mode =
					&pipe_config->hw.adjusted_mode;
	struct drm_display_mode *adjusted_mode_sw;
	struct intel_crtc *crtc = to_intel_crtc(pipe_config->uapi.crtc);
	struct intel_dsi *intel_dsi = enc_to_intel_dsi(encoder);
	unsigned int lane_count = intel_dsi->lane_count;
	unsigned int bpp, fmt;
	enum port port;
	u16 hactive, hfp, hsync, hbp, vfp, vsync, vbp;
	u16 hfp_sw, hsync_sw, hbp_sw;
	u16 crtc_htotal_sw, crtc_hsync_start_sw, crtc_hsync_end_sw,
				crtc_hblank_start_sw, crtc_hblank_end_sw;

	/* FIXME: hw readout should not depend on SW state */
	adjusted_mode_sw = &crtc->config->hw.adjusted_mode;

	/*
	 * Atleast one port is active as encoder->get_config called only if
	 * encoder->get_hw_state() returns true.
	 */
	for_each_dsi_port(port, intel_dsi->ports) {
		if (intel_de_read(dev_priv, BXT_MIPI_PORT_CTRL(port)) & DPI_ENABLE)
			break;
	}

	fmt = intel_de_read(dev_priv, MIPI_DSI_FUNC_PRG(port)) & VID_MODE_FORMAT_MASK;
	bpp = mipi_dsi_pixel_format_to_bpp(
			pixel_format_from_register_bits(fmt));

	pipe_config->pipe_bpp = bdw_get_pipemisc_bpp(crtc);

	/* Enable Frame time stamo based scanline reporting */
	pipe_config->mode_flags |=
		I915_MODE_FLAG_GET_SCANLINE_FROM_TIMESTAMP;

	/* In terms of pixels */
	adjusted_mode->crtc_hdisplay =
				intel_de_read(dev_priv,
				              BXT_MIPI_TRANS_HACTIVE(port));
	adjusted_mode->crtc_vdisplay =
				intel_de_read(dev_priv,
				              BXT_MIPI_TRANS_VACTIVE(port));
	adjusted_mode->crtc_vtotal =
				intel_de_read(dev_priv,
				              BXT_MIPI_TRANS_VTOTAL(port));

	hactive = adjusted_mode->crtc_hdisplay;
	hfp = intel_de_read(dev_priv, MIPI_HFP_COUNT(port));

	/*
	 * Meaningful for video mode non-burst sync pulse mode only,
	 * can be zero for non-burst sync events and burst modes
	 */
	hsync = intel_de_read(dev_priv, MIPI_HSYNC_PADDING_COUNT(port));
	hbp = intel_de_read(dev_priv, MIPI_HBP_COUNT(port));

	/* harizontal values are in terms of high speed byte clock */
	hfp = pixels_from_txbyteclkhs(hfp, bpp, lane_count,
						intel_dsi->burst_mode_ratio);
	hsync = pixels_from_txbyteclkhs(hsync, bpp, lane_count,
						intel_dsi->burst_mode_ratio);
	hbp = pixels_from_txbyteclkhs(hbp, bpp, lane_count,
						intel_dsi->burst_mode_ratio);

	if (intel_dsi->dual_link) {
		hfp *= 2;
		hsync *= 2;
		hbp *= 2;
	}

	/* vertical values are in terms of lines */
	vfp = intel_de_read(dev_priv, MIPI_VFP_COUNT(port));
	vsync = intel_de_read(dev_priv, MIPI_VSYNC_PADDING_COUNT(port));
	vbp = intel_de_read(dev_priv, MIPI_VBP_COUNT(port));

	adjusted_mode->crtc_htotal = hactive + hfp + hsync + hbp;
	adjusted_mode->crtc_hsync_start = hfp + adjusted_mode->crtc_hdisplay;
	adjusted_mode->crtc_hsync_end = hsync + adjusted_mode->crtc_hsync_start;
	adjusted_mode->crtc_hblank_start = adjusted_mode->crtc_hdisplay;
	adjusted_mode->crtc_hblank_end = adjusted_mode->crtc_htotal;

	adjusted_mode->crtc_vsync_start = vfp + adjusted_mode->crtc_vdisplay;
	adjusted_mode->crtc_vsync_end = vsync + adjusted_mode->crtc_vsync_start;
	adjusted_mode->crtc_vblank_start = adjusted_mode->crtc_vdisplay;
	adjusted_mode->crtc_vblank_end = adjusted_mode->crtc_vtotal;

	/*
	 * In BXT DSI there is no regs programmed with few horizontal timings
	 * in Pixels but txbyteclkhs.. So retrieval process adds some
	 * ROUND_UP ERRORS in the process of PIXELS<==>txbyteclkhs.
	 * Actually here for the given adjusted_mode, we are calculating the
	 * value programmed to the port and then back to the horizontal timing
	 * param in pixels. This is the expected value, including roundup errors
	 * And if that is same as retrieved value from port, then
	 * (HW state) adjusted_mode's horizontal timings are corrected to
	 * match with SW state to nullify the errors.
	 */
	/* Calculating the value programmed to the Port register */
	hfp_sw = adjusted_mode_sw->crtc_hsync_start -
					adjusted_mode_sw->crtc_hdisplay;
	hsync_sw = adjusted_mode_sw->crtc_hsync_end -
					adjusted_mode_sw->crtc_hsync_start;
	hbp_sw = adjusted_mode_sw->crtc_htotal -
					adjusted_mode_sw->crtc_hsync_end;

	if (intel_dsi->dual_link) {
		hfp_sw /= 2;
		hsync_sw /= 2;
		hbp_sw /= 2;
	}

	hfp_sw = txbyteclkhs(hfp_sw, bpp, lane_count,
						intel_dsi->burst_mode_ratio);
	hsync_sw = txbyteclkhs(hsync_sw, bpp, lane_count,
			    intel_dsi->burst_mode_ratio);
	hbp_sw = txbyteclkhs(hbp_sw, bpp, lane_count,
						intel_dsi->burst_mode_ratio);

	/* Reverse calculating the adjusted mode parameters from port reg vals*/
	hfp_sw = pixels_from_txbyteclkhs(hfp_sw, bpp, lane_count,
						intel_dsi->burst_mode_ratio);
	hsync_sw = pixels_from_txbyteclkhs(hsync_sw, bpp, lane_count,
						intel_dsi->burst_mode_ratio);
	hbp_sw = pixels_from_txbyteclkhs(hbp_sw, bpp, lane_count,
						intel_dsi->burst_mode_ratio);

	if (intel_dsi->dual_link) {
		hfp_sw *= 2;
		hsync_sw *= 2;
		hbp_sw *= 2;
	}

	crtc_htotal_sw = adjusted_mode_sw->crtc_hdisplay + hfp_sw +
							hsync_sw + hbp_sw;
	crtc_hsync_start_sw = hfp_sw + adjusted_mode_sw->crtc_hdisplay;
	crtc_hsync_end_sw = hsync_sw + crtc_hsync_start_sw;
	crtc_hblank_start_sw = adjusted_mode_sw->crtc_hdisplay;
	crtc_hblank_end_sw = crtc_htotal_sw;

	if (adjusted_mode->crtc_htotal == crtc_htotal_sw)
		adjusted_mode->crtc_htotal = adjusted_mode_sw->crtc_htotal;

	if (adjusted_mode->crtc_hsync_start == crtc_hsync_start_sw)
		adjusted_mode->crtc_hsync_start =
					adjusted_mode_sw->crtc_hsync_start;

	if (adjusted_mode->crtc_hsync_end == crtc_hsync_end_sw)
		adjusted_mode->crtc_hsync_end =
					adjusted_mode_sw->crtc_hsync_end;

	if (adjusted_mode->crtc_hblank_start == crtc_hblank_start_sw)
		adjusted_mode->crtc_hblank_start =
					adjusted_mode_sw->crtc_hblank_start;

	if (adjusted_mode->crtc_hblank_end == crtc_hblank_end_sw)
		adjusted_mode->crtc_hblank_end =
					adjusted_mode_sw->crtc_hblank_end;
}

static void intel_dsi_get_config(struct intel_encoder *encoder,
				 struct intel_crtc_state *pipe_config)
{
	struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
	struct intel_dsi *intel_dsi = enc_to_intel_dsi(encoder);
	u32 pclk;

	drm_dbg_kms(&dev_priv->drm, "\n");

	pipe_config->output_types |= BIT(INTEL_OUTPUT_DSI);

	if (IS_GEMINILAKE(dev_priv) || IS_BROXTON(dev_priv)) {
		bxt_dsi_get_pipe_config(encoder, pipe_config);
		pclk = bxt_dsi_get_pclk(encoder, pipe_config);
	} else {
		pclk = vlv_dsi_get_pclk(encoder, pipe_config);
	}

	pipe_config->port_clock = pclk;

	/* FIXME definitely not right for burst/cmd mode/pixel overlap */
	pipe_config->hw.adjusted_mode.crtc_clock = pclk;
	if (intel_dsi->dual_link)
		pipe_config->hw.adjusted_mode.crtc_clock *= 2;
}

/* return txclkesc cycles in terms of divider and duration in us */
static u16 txclkesc(u32 divider, unsigned int us)
{
	switch (divider) {
	case ESCAPE_CLOCK_DIVIDER_1:
	default:
		return 20 * us;
	case ESCAPE_CLOCK_DIVIDER_2:
		return 10 * us;
	case ESCAPE_CLOCK_DIVIDER_4:
		return 5 * us;
	}
}

static void set_dsi_timings(struct drm_encoder *encoder,
			    const struct drm_display_mode *adjusted_mode)
{
	struct drm_device *dev = encoder->dev;
	struct drm_i915_private *dev_priv = to_i915(dev);
	struct intel_dsi *intel_dsi = enc_to_intel_dsi(to_intel_encoder(encoder));
	enum port port;
	unsigned int bpp = mipi_dsi_pixel_format_to_bpp(intel_dsi->pixel_format);
	unsigned int lane_count = intel_dsi->lane_count;

	u16 hactive, hfp, hsync, hbp, vfp, vsync, vbp;

	hactive = adjusted_mode->crtc_hdisplay;
	hfp = adjusted_mode->crtc_hsync_start - adjusted_mode->crtc_hdisplay;
	hsync = adjusted_mode->crtc_hsync_end - adjusted_mode->crtc_hsync_start;
	hbp = adjusted_mode->crtc_htotal - adjusted_mode->crtc_hsync_end;

	if (intel_dsi->dual_link) {
		hactive /= 2;
		if (intel_dsi->dual_link == DSI_DUAL_LINK_FRONT_BACK)
			hactive += intel_dsi->pixel_overlap;
		hfp /= 2;
		hsync /= 2;
		hbp /= 2;
	}

	vfp = adjusted_mode->crtc_vsync_start - adjusted_mode->crtc_vdisplay;
	vsync = adjusted_mode->crtc_vsync_end - adjusted_mode->crtc_vsync_start;
	vbp = adjusted_mode->crtc_vtotal - adjusted_mode->crtc_vsync_end;

	/* horizontal values are in terms of high speed byte clock */
	hactive = txbyteclkhs(hactive, bpp, lane_count,
			      intel_dsi->burst_mode_ratio);
	hfp = txbyteclkhs(hfp, bpp, lane_count, intel_dsi->burst_mode_ratio);
	hsync = txbyteclkhs(hsync, bpp, lane_count,
			    intel_dsi->burst_mode_ratio);
	hbp = txbyteclkhs(hbp, bpp, lane_count, intel_dsi->burst_mode_ratio);

	for_each_dsi_port(port, intel_dsi->ports) {
		if (IS_GEMINILAKE(dev_priv) || IS_BROXTON(dev_priv)) {
			/*
			 * Program hdisplay and vdisplay on MIPI transcoder.
			 * This is different from calculated hactive and
			 * vactive, as they are calculated per channel basis,
			 * whereas these values should be based on resolution.
			 */
			intel_de_write(dev_priv, BXT_MIPI_TRANS_HACTIVE(port),
				       adjusted_mode->crtc_hdisplay);
			intel_de_write(dev_priv, BXT_MIPI_TRANS_VACTIVE(port),
				       adjusted_mode->crtc_vdisplay);
			intel_de_write(dev_priv, BXT_MIPI_TRANS_VTOTAL(port),
				       adjusted_mode->crtc_vtotal);
		}

		intel_de_write(dev_priv, MIPI_HACTIVE_AREA_COUNT(port),
			       hactive);
		intel_de_write(dev_priv, MIPI_HFP_COUNT(port), hfp);

		/* meaningful for video mode non-burst sync pulse mode only,
		 * can be zero for non-burst sync events and burst modes */
		intel_de_write(dev_priv, MIPI_HSYNC_PADDING_COUNT(port),
			       hsync);
		intel_de_write(dev_priv, MIPI_HBP_COUNT(port), hbp);

		/* vertical values are in terms of lines */
		intel_de_write(dev_priv, MIPI_VFP_COUNT(port), vfp);
		intel_de_write(dev_priv, MIPI_VSYNC_PADDING_COUNT(port),
			       vsync);
		intel_de_write(dev_priv, MIPI_VBP_COUNT(port), vbp);
	}
}

static u32 pixel_format_to_reg(enum mipi_dsi_pixel_format fmt)
{
	switch (fmt) {
	case MIPI_DSI_FMT_RGB888:
		return VID_MODE_FORMAT_RGB888;
	case MIPI_DSI_FMT_RGB666:
		return VID_MODE_FORMAT_RGB666;
	case MIPI_DSI_FMT_RGB666_PACKED:
		return VID_MODE_FORMAT_RGB666_PACKED;
	case MIPI_DSI_FMT_RGB565:
		return VID_MODE_FORMAT_RGB565;
	default:
		MISSING_CASE(fmt);
		return VID_MODE_FORMAT_RGB666;
	}
}

static void intel_dsi_prepare(struct intel_encoder *intel_encoder,
			      const struct intel_crtc_state *pipe_config)
{
	struct drm_encoder *encoder = &intel_encoder->base;
	struct drm_device *dev = encoder->dev;
	struct drm_i915_private *dev_priv = to_i915(dev);
	struct intel_crtc *crtc = to_intel_crtc(pipe_config->uapi.crtc);
	struct intel_dsi *intel_dsi = enc_to_intel_dsi(to_intel_encoder(encoder));
	const struct drm_display_mode *adjusted_mode = &pipe_config->hw.adjusted_mode;
	enum port port;
	unsigned int bpp = mipi_dsi_pixel_format_to_bpp(intel_dsi->pixel_format);
	u32 val, tmp;
	u16 mode_hdisplay;

	drm_dbg_kms(&dev_priv->drm, "pipe %c\n", pipe_name(crtc->pipe));

	mode_hdisplay = adjusted_mode->crtc_hdisplay;

	if (intel_dsi->dual_link) {
		mode_hdisplay /= 2;
		if (intel_dsi->dual_link == DSI_DUAL_LINK_FRONT_BACK)
			mode_hdisplay += intel_dsi->pixel_overlap;
	}

	for_each_dsi_port(port, intel_dsi->ports) {
		if (IS_VALLEYVIEW(dev_priv) || IS_CHERRYVIEW(dev_priv)) {
			/*
			 * escape clock divider, 20MHz, shared for A and C.
			 * device ready must be off when doing this! txclkesc?
			 */
			tmp = intel_de_read(dev_priv, MIPI_CTRL(PORT_A));
			tmp &= ~ESCAPE_CLOCK_DIVIDER_MASK;
			intel_de_write(dev_priv, MIPI_CTRL(PORT_A),
				       tmp | ESCAPE_CLOCK_DIVIDER_1);

			/* read request priority is per pipe */
			tmp = intel_de_read(dev_priv, MIPI_CTRL(port));
			tmp &= ~READ_REQUEST_PRIORITY_MASK;
			intel_de_write(dev_priv, MIPI_CTRL(port),
				       tmp | READ_REQUEST_PRIORITY_HIGH);
		} else if (IS_GEMINILAKE(dev_priv) || IS_BROXTON(dev_priv)) {
			enum pipe pipe = crtc->pipe;

			tmp = intel_de_read(dev_priv, MIPI_CTRL(port));
			tmp &= ~BXT_PIPE_SELECT_MASK;

			tmp |= BXT_PIPE_SELECT(pipe);
			intel_de_write(dev_priv, MIPI_CTRL(port), tmp);
		}

		/* XXX: why here, why like this? handling in irq handler?! */
		intel_de_write(dev_priv, MIPI_INTR_STAT(port), 0xffffffff);
		intel_de_write(dev_priv, MIPI_INTR_EN(port), 0xffffffff);

		intel_de_write(dev_priv, MIPI_DPHY_PARAM(port),
			       intel_dsi->dphy_reg);

		intel_de_write(dev_priv, MIPI_DPI_RESOLUTION(port),
			       adjusted_mode->crtc_vdisplay << VERTICAL_ADDRESS_SHIFT | mode_hdisplay << HORIZONTAL_ADDRESS_SHIFT);
	}

	set_dsi_timings(encoder, adjusted_mode);

	val = intel_dsi->lane_count << DATA_LANES_PRG_REG_SHIFT;
	if (is_cmd_mode(intel_dsi)) {
		val |= intel_dsi->channel << CMD_MODE_CHANNEL_NUMBER_SHIFT;
		val |= CMD_MODE_DATA_WIDTH_8_BIT; /* XXX */
	} else {
		val |= intel_dsi->channel << VID_MODE_CHANNEL_NUMBER_SHIFT;
		val |= pixel_format_to_reg(intel_dsi->pixel_format);
	}

	tmp = 0;
	if (intel_dsi->eotp_pkt == 0)
		tmp |= EOT_DISABLE;
	if (intel_dsi->clock_stop)
		tmp |= CLOCKSTOP;

	if (IS_GEMINILAKE(dev_priv) || IS_BROXTON(dev_priv)) {
		tmp |= BXT_DPHY_DEFEATURE_EN;
		if (!is_cmd_mode(intel_dsi))
			tmp |= BXT_DEFEATURE_DPI_FIFO_CTR;
	}

	for_each_dsi_port(port, intel_dsi->ports) {
		intel_de_write(dev_priv, MIPI_DSI_FUNC_PRG(port), val);

		/* timeouts for recovery. one frame IIUC. if counter expires,
		 * EOT and stop state. */

		/*
		 * In burst mode, value greater than one DPI line Time in byte
		 * clock (txbyteclkhs) To timeout this timer 1+ of the above
		 * said value is recommended.
		 *
		 * In non-burst mode, Value greater than one DPI frame time in
		 * byte clock(txbyteclkhs) To timeout this timer 1+ of the above
		 * said value is recommended.
		 *
		 * In DBI only mode, value greater than one DBI frame time in
		 * byte clock(txbyteclkhs) To timeout this timer 1+ of the above
		 * said value is recommended.
		 */

		if (is_vid_mode(intel_dsi) &&
			intel_dsi->video_mode == BURST_MODE) {
			intel_de_write(dev_priv, MIPI_HS_TX_TIMEOUT(port),
				       txbyteclkhs(adjusted_mode->crtc_htotal, bpp, intel_dsi->lane_count, intel_dsi->burst_mode_ratio) + 1);
		} else {
			intel_de_write(dev_priv, MIPI_HS_TX_TIMEOUT(port),
				       txbyteclkhs(adjusted_mode->crtc_vtotal * adjusted_mode->crtc_htotal, bpp, intel_dsi->lane_count, intel_dsi->burst_mode_ratio) + 1);
		}
		intel_de_write(dev_priv, MIPI_LP_RX_TIMEOUT(port),
			       intel_dsi->lp_rx_timeout);
		intel_de_write(dev_priv, MIPI_TURN_AROUND_TIMEOUT(port),
			       intel_dsi->turn_arnd_val);
		intel_de_write(dev_priv, MIPI_DEVICE_RESET_TIMER(port),
			       intel_dsi->rst_timer_val);

		/* dphy stuff */

		/* in terms of low power clock */
		intel_de_write(dev_priv, MIPI_INIT_COUNT(port),
			       txclkesc(intel_dsi->escape_clk_div, 100));

		if ((IS_GEMINILAKE(dev_priv) || IS_BROXTON(dev_priv)) &&
		    !intel_dsi->dual_link) {
			/*
			 * BXT spec says write MIPI_INIT_COUNT for
			 * both the ports, even if only one is
			 * getting used. So write the other port
			 * if not in dual link mode.
			 */
			intel_de_write(dev_priv,
				       MIPI_INIT_COUNT(port == PORT_A ? PORT_C : PORT_A),
				       intel_dsi->init_count);
		}

		/* recovery disables */
		intel_de_write(dev_priv, MIPI_EOT_DISABLE(port), tmp);

		/* in terms of low power clock */
		intel_de_write(dev_priv, MIPI_INIT_COUNT(port),
			       intel_dsi->init_count);

		/* in terms of txbyteclkhs. actual high to low switch +
		 * MIPI_STOP_STATE_STALL * MIPI_LP_BYTECLK.
		 *
		 * XXX: write MIPI_STOP_STATE_STALL?
		 */
		intel_de_write(dev_priv, MIPI_HIGH_LOW_SWITCH_COUNT(port),
			       intel_dsi->hs_to_lp_count);

		/* XXX: low power clock equivalence in terms of byte clock.
		 * the number of byte clocks occupied in one low power clock.
		 * based on txbyteclkhs and txclkesc.
		 * txclkesc time / txbyteclk time * (105 + MIPI_STOP_STATE_STALL
		 * ) / 105.???
		 */
		intel_de_write(dev_priv, MIPI_LP_BYTECLK(port),
			       intel_dsi->lp_byte_clk);

		if (IS_GEMINILAKE(dev_priv)) {
			intel_de_write(dev_priv, MIPI_TLPX_TIME_COUNT(port),
				       intel_dsi->lp_byte_clk);
			/* Shadow of DPHY reg */
			intel_de_write(dev_priv, MIPI_CLK_LANE_TIMING(port),
				       intel_dsi->dphy_reg);
		}

		/* the bw essential for transmitting 16 long packets containing
		 * 252 bytes meant for dcs write memory command is programmed in
		 * this register in terms of byte clocks. based on dsi transfer
		 * rate and the number of lanes configured the time taken to
		 * transmit 16 long packets in a dsi stream varies. */
		intel_de_write(dev_priv, MIPI_DBI_BW_CTRL(port),
			       intel_dsi->bw_timer);

		intel_de_write(dev_priv, MIPI_CLK_LANE_SWITCH_TIME_CNT(port),
			       intel_dsi->clk_lp_to_hs_count << LP_HS_SSW_CNT_SHIFT | intel_dsi->clk_hs_to_lp_count << HS_LP_PWR_SW_CNT_SHIFT);

		if (is_vid_mode(intel_dsi)) {
			u32 fmt = intel_dsi->video_frmt_cfg_bits | IP_TG_CONFIG;

			/*
			 * Some panels might have resolution which is not a
			 * multiple of 64 like 1366 x 768. Enable RANDOM
			 * resolution support for such panels by default.
			 */
			fmt |= RANDOM_DPI_DISPLAY_RESOLUTION;

			switch (intel_dsi->video_mode) {
			default:
				MISSING_CASE(intel_dsi->video_mode);
				fallthrough;
			case NON_BURST_SYNC_EVENTS:
				fmt |= VIDEO_MODE_NON_BURST_WITH_SYNC_EVENTS;
				break;
			case NON_BURST_SYNC_PULSE:
				fmt |= VIDEO_MODE_NON_BURST_WITH_SYNC_PULSE;
				break;
			case BURST_MODE:
				fmt |= VIDEO_MODE_BURST;
				break;
			}

			intel_de_write(dev_priv, MIPI_VIDEO_MODE_FORMAT(port), fmt);
		}
	}
}

static void intel_dsi_unprepare(struct intel_encoder *encoder)
{
	struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
	struct intel_dsi *intel_dsi = enc_to_intel_dsi(encoder);
	enum port port;
	u32 val;

	if (IS_GEMINILAKE(dev_priv))
		return;

	for_each_dsi_port(port, intel_dsi->ports) {
		/* Panel commands can be sent when clock is in LP11 */
		intel_de_write(dev_priv, MIPI_DEVICE_READY(port), 0x0);

		if (IS_GEMINILAKE(dev_priv) || IS_BROXTON(dev_priv))
			bxt_dsi_reset_clocks(encoder, port);
		else
			vlv_dsi_reset_clocks(encoder, port);
		intel_de_write(dev_priv, MIPI_EOT_DISABLE(port), CLOCKSTOP);

		val = intel_de_read(dev_priv, MIPI_DSI_FUNC_PRG(port));
		val &= ~VID_MODE_FORMAT_MASK;
		intel_de_write(dev_priv, MIPI_DSI_FUNC_PRG(port), val);

		intel_de_write(dev_priv, MIPI_DEVICE_READY(port), 0x1);
	}
}

static void intel_dsi_encoder_destroy(struct drm_encoder *encoder)
{
	struct intel_dsi *intel_dsi = enc_to_intel_dsi(to_intel_encoder(encoder));

	intel_dsi_vbt_gpio_cleanup(intel_dsi);
	intel_encoder_destroy(encoder);
}

static const struct drm_encoder_funcs intel_dsi_funcs = {
	.destroy = intel_dsi_encoder_destroy,
};

static const struct drm_connector_helper_funcs intel_dsi_connector_helper_funcs = {
	.get_modes = intel_dsi_get_modes,
	.mode_valid = intel_dsi_mode_valid,
	.atomic_check = intel_digital_connector_atomic_check,
};

static const struct drm_connector_funcs intel_dsi_connector_funcs = {
	.detect = intel_panel_detect,
	.late_register = intel_connector_register,
	.early_unregister = intel_connector_unregister,
	.destroy = intel_connector_destroy,
	.fill_modes = drm_helper_probe_single_connector_modes,
	.atomic_get_property = intel_digital_connector_atomic_get_property,
	.atomic_set_property = intel_digital_connector_atomic_set_property,
	.atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
	.atomic_duplicate_state = intel_digital_connector_duplicate_state,
};

static void vlv_dsi_add_properties(struct intel_connector *connector)
{
	const struct drm_display_mode *fixed_mode =
		intel_panel_preferred_fixed_mode(connector);

	intel_attach_scaling_mode_property(&connector->base);

	drm_connector_set_panel_orientation_with_quirk(&connector->base,
						       intel_dsi_get_panel_orientation(connector),
						       fixed_mode->hdisplay,
						       fixed_mode->vdisplay);
}

#define NS_KHZ_RATIO		1000000

#define PREPARE_CNT_MAX		0x3F
#define EXIT_ZERO_CNT_MAX	0x3F
#define CLK_ZERO_CNT_MAX	0xFF
#define TRAIL_CNT_MAX		0x1F

static void vlv_dphy_param_init(struct intel_dsi *intel_dsi)
{
	struct drm_device *dev = intel_dsi->base.base.dev;
	struct drm_i915_private *dev_priv = to_i915(dev);
	struct intel_connector *connector = intel_dsi->attached_connector;
	struct mipi_config *mipi_config = connector->panel.vbt.dsi.config;
	u32 tlpx_ns, extra_byte_count, tlpx_ui;
	u32 ui_num, ui_den;
	u32 prepare_cnt, exit_zero_cnt, clk_zero_cnt, trail_cnt;
	u32 ths_prepare_ns, tclk_trail_ns;
	u32 tclk_prepare_clkzero, ths_prepare_hszero;
	u32 lp_to_hs_switch, hs_to_lp_switch;
	u32 mul;

	tlpx_ns = intel_dsi_tlpx_ns(intel_dsi);

	switch (intel_dsi->lane_count) {
	case 1:
	case 2:
		extra_byte_count = 2;
		break;
	case 3:
		extra_byte_count = 4;
		break;
	case 4:
	default:
		extra_byte_count = 3;
		break;
	}

	/* in Kbps */
	ui_num = NS_KHZ_RATIO;
	ui_den = intel_dsi_bitrate(intel_dsi);

	tclk_prepare_clkzero = mipi_config->tclk_prepare_clkzero;
	ths_prepare_hszero = mipi_config->ths_prepare_hszero;

	/*
	 * B060
	 * LP byte clock = TLPX/ (8UI)
	 */
	intel_dsi->lp_byte_clk = DIV_ROUND_UP(tlpx_ns * ui_den, 8 * ui_num);

	/* DDR clock period = 2 * UI
	 * UI(sec) = 1/(bitrate * 10^3) (bitrate is in KHZ)
	 * UI(nsec) = 10^6 / bitrate
	 * DDR clock period (nsec) = 2 * UI = (2 * 10^6)/ bitrate
	 * DDR clock count  = ns_value / DDR clock period
	 *
	 * For GEMINILAKE dphy_param_reg will be programmed in terms of
	 * HS byte clock count for other platform in HS ddr clock count
	 */
	mul = IS_GEMINILAKE(dev_priv) ? 8 : 2;
	ths_prepare_ns = max(mipi_config->ths_prepare,
			     mipi_config->tclk_prepare);

	/* prepare count */
	prepare_cnt = DIV_ROUND_UP(ths_prepare_ns * ui_den, ui_num * mul);

	if (prepare_cnt > PREPARE_CNT_MAX) {
		drm_dbg_kms(&dev_priv->drm, "prepare count too high %u\n",
			    prepare_cnt);
		prepare_cnt = PREPARE_CNT_MAX;
	}

	/* exit zero count */
	exit_zero_cnt = DIV_ROUND_UP(
				(ths_prepare_hszero - ths_prepare_ns) * ui_den,
				ui_num * mul
				);

	/*
	 * Exit zero is unified val ths_zero and ths_exit
	 * minimum value for ths_exit = 110ns
	 * min (exit_zero_cnt * 2) = 110/UI
	 * exit_zero_cnt = 55/UI
	 */
	if (exit_zero_cnt < (55 * ui_den / ui_num) && (55 * ui_den) % ui_num)
		exit_zero_cnt += 1;

	if (exit_zero_cnt > EXIT_ZERO_CNT_MAX) {
		drm_dbg_kms(&dev_priv->drm, "exit zero count too high %u\n",
			    exit_zero_cnt);
		exit_zero_cnt = EXIT_ZERO_CNT_MAX;
	}

	/* clk zero count */
	clk_zero_cnt = DIV_ROUND_UP(
				(tclk_prepare_clkzero -	ths_prepare_ns)
				* ui_den, ui_num * mul);

	if (clk_zero_cnt > CLK_ZERO_CNT_MAX) {
		drm_dbg_kms(&dev_priv->drm, "clock zero count too high %u\n",
			    clk_zero_cnt);
		clk_zero_cnt = CLK_ZERO_CNT_MAX;
	}

	/* trail count */
	tclk_trail_ns = max(mipi_config->tclk_trail, mipi_config->ths_trail);
	trail_cnt = DIV_ROUND_UP(tclk_trail_ns * ui_den, ui_num * mul);

	if (trail_cnt > TRAIL_CNT_MAX) {
		drm_dbg_kms(&dev_priv->drm, "trail count too high %u\n",
			    trail_cnt);
		trail_cnt = TRAIL_CNT_MAX;
	}

	/* B080 */
	intel_dsi->dphy_reg = exit_zero_cnt << 24 | trail_cnt << 16 |
						clk_zero_cnt << 8 | prepare_cnt;

	/*
	 * LP to HS switch count = 4TLPX + PREP_COUNT * mul + EXIT_ZERO_COUNT *
	 *					mul + 10UI + Extra Byte Count
	 *
	 * HS to LP switch count = THS-TRAIL + 2TLPX + Extra Byte Count
	 * Extra Byte Count is calculated according to number of lanes.
	 * High Low Switch Count is the Max of LP to HS and
	 * HS to LP switch count
	 *
	 */
	tlpx_ui = DIV_ROUND_UP(tlpx_ns * ui_den, ui_num);

	/* B044 */
	/* FIXME:
	 * The comment above does not match with the code */
	lp_to_hs_switch = DIV_ROUND_UP(4 * tlpx_ui + prepare_cnt * mul +
						exit_zero_cnt * mul + 10, 8);

	hs_to_lp_switch = DIV_ROUND_UP(mipi_config->ths_trail + 2 * tlpx_ui, 8);

	intel_dsi->hs_to_lp_count = max(lp_to_hs_switch, hs_to_lp_switch);
	intel_dsi->hs_to_lp_count += extra_byte_count;

	/* B088 */
	/* LP -> HS for clock lanes
	 * LP clk sync + LP11 + LP01 + tclk_prepare + tclk_zero +
	 *						extra byte count
	 * 2TPLX + 1TLPX + 1 TPLX(in ns) + prepare_cnt * 2 + clk_zero_cnt *
	 *					2(in UI) + extra byte count
	 * In byteclks = (4TLPX + prepare_cnt * 2 + clk_zero_cnt *2 (in UI)) /
	 *					8 + extra byte count
	 */
	intel_dsi->clk_lp_to_hs_count =
		DIV_ROUND_UP(
			4 * tlpx_ui + prepare_cnt * 2 +
			clk_zero_cnt * 2,
			8);

	intel_dsi->clk_lp_to_hs_count += extra_byte_count;

	/* HS->LP for Clock Lanes
	 * Low Power clock synchronisations + 1Tx byteclk + tclk_trail +
	 *						Extra byte count
	 * 2TLPX + 8UI + (trail_count*2)(in UI) + Extra byte count
	 * In byteclks = (2*TLpx(in UI) + trail_count*2 +8)(in UI)/8 +
	 *						Extra byte count
	 */
	intel_dsi->clk_hs_to_lp_count =
		DIV_ROUND_UP(2 * tlpx_ui + trail_cnt * 2 + 8,
			8);
	intel_dsi->clk_hs_to_lp_count += extra_byte_count;

	intel_dsi_log_params(intel_dsi);
}

void vlv_dsi_init(struct drm_i915_private *dev_priv)
{
	struct intel_dsi *intel_dsi;
	struct intel_encoder *intel_encoder;
	struct drm_encoder *encoder;
	struct intel_connector *intel_connector;
	struct drm_connector *connector;
	struct drm_display_mode *current_mode;
	enum port port;
	enum pipe pipe;

	drm_dbg_kms(&dev_priv->drm, "\n");

	/* There is no detection method for MIPI so rely on VBT */
	if (!intel_bios_is_dsi_present(dev_priv, &port))
		return;

	if (IS_GEMINILAKE(dev_priv) || IS_BROXTON(dev_priv))
		dev_priv->display.dsi.mmio_base = BXT_MIPI_BASE;
	else
		dev_priv->display.dsi.mmio_base = VLV_MIPI_BASE;

	intel_dsi = kzalloc(sizeof(*intel_dsi), GFP_KERNEL);
	if (!intel_dsi)
		return;

	intel_connector = intel_connector_alloc();
	if (!intel_connector) {
		kfree(intel_dsi);
		return;
	}

	intel_encoder = &intel_dsi->base;
	encoder = &intel_encoder->base;
	intel_dsi->attached_connector = intel_connector;

	connector = &intel_connector->base;

	drm_encoder_init(&dev_priv->drm, encoder, &intel_dsi_funcs, DRM_MODE_ENCODER_DSI,
			 "DSI %c", port_name(port));

	intel_encoder->compute_config = intel_dsi_compute_config;
	intel_encoder->pre_enable = intel_dsi_pre_enable;
	if (IS_GEMINILAKE(dev_priv) || IS_BROXTON(dev_priv))
		intel_encoder->enable = bxt_dsi_enable;
	intel_encoder->disable = intel_dsi_disable;
	intel_encoder->post_disable = intel_dsi_post_disable;
	intel_encoder->get_hw_state = intel_dsi_get_hw_state;
	intel_encoder->get_config = intel_dsi_get_config;
	intel_encoder->update_pipe = intel_backlight_update;
	intel_encoder->shutdown = intel_dsi_shutdown;

	intel_connector->get_hw_state = intel_connector_get_hw_state;

	intel_encoder->port = port;
	intel_encoder->type = INTEL_OUTPUT_DSI;
	intel_encoder->power_domain = POWER_DOMAIN_PORT_DSI;
	intel_encoder->cloneable = 0;

	/*
	 * On BYT/CHV, pipe A maps to MIPI DSI port A, pipe B maps to MIPI DSI
	 * port C. BXT isn't limited like this.
	 */
	if (IS_GEMINILAKE(dev_priv) || IS_BROXTON(dev_priv))
		intel_encoder->pipe_mask = ~0;
	else if (port == PORT_A)
		intel_encoder->pipe_mask = BIT(PIPE_A);
	else
		intel_encoder->pipe_mask = BIT(PIPE_B);

	intel_dsi->panel_power_off_time = ktime_get_boottime();

	intel_bios_init_panel_late(dev_priv, &intel_connector->panel, NULL, NULL);

	if (intel_connector->panel.vbt.dsi.config->dual_link)
		intel_dsi->ports = BIT(PORT_A) | BIT(PORT_C);
	else
		intel_dsi->ports = BIT(port);

	if (drm_WARN_ON(&dev_priv->drm, intel_connector->panel.vbt.dsi.bl_ports & ~intel_dsi->ports))
		intel_connector->panel.vbt.dsi.bl_ports &= intel_dsi->ports;

	if (drm_WARN_ON(&dev_priv->drm, intel_connector->panel.vbt.dsi.cabc_ports & ~intel_dsi->ports))
		intel_connector->panel.vbt.dsi.cabc_ports &= intel_dsi->ports;

	/* Create a DSI host (and a device) for each port. */
	for_each_dsi_port(port, intel_dsi->ports) {
		struct intel_dsi_host *host;

		host = intel_dsi_host_init(intel_dsi, &intel_dsi_host_ops,
					   port);
		if (!host)
			goto err;

		intel_dsi->dsi_hosts[port] = host;
	}

	if (!intel_dsi_vbt_init(intel_dsi, MIPI_DSI_GENERIC_PANEL_ID)) {
		drm_dbg_kms(&dev_priv->drm, "no device found\n");
		goto err;
	}

	/* Use clock read-back from current hw-state for fastboot */
	current_mode = intel_encoder_current_mode(intel_encoder);
	if (current_mode) {
		drm_dbg_kms(&dev_priv->drm, "Calculated pclk %d GOP %d\n",
			    intel_dsi->pclk, current_mode->clock);
		if (intel_fuzzy_clock_check(intel_dsi->pclk,
					    current_mode->clock)) {
			drm_dbg_kms(&dev_priv->drm, "Using GOP pclk\n");
			intel_dsi->pclk = current_mode->clock;
		}

		kfree(current_mode);
	}

	vlv_dphy_param_init(intel_dsi);

	intel_dsi_vbt_gpio_init(intel_dsi,
				intel_dsi_get_hw_state(intel_encoder, &pipe));

	drm_connector_init(&dev_priv->drm, connector, &intel_dsi_connector_funcs,
			   DRM_MODE_CONNECTOR_DSI);

	drm_connector_helper_add(connector, &intel_dsi_connector_helper_funcs);

	connector->display_info.subpixel_order = SubPixelHorizontalRGB; /*XXX*/

	intel_connector_attach_encoder(intel_connector, intel_encoder);

	mutex_lock(&dev_priv->drm.mode_config.mutex);
	intel_panel_add_vbt_lfp_fixed_mode(intel_connector);
	mutex_unlock(&dev_priv->drm.mode_config.mutex);

	if (!intel_panel_preferred_fixed_mode(intel_connector)) {
		drm_dbg_kms(&dev_priv->drm, "no fixed mode\n");
		goto err_cleanup_connector;
	}

	intel_panel_init(intel_connector);

	intel_backlight_setup(intel_connector, INVALID_PIPE);

	vlv_dsi_add_properties(intel_connector);

	return;

err_cleanup_connector:
	drm_connector_cleanup(&intel_connector->base);
err:
	drm_encoder_cleanup(&intel_encoder->base);
	kfree(intel_dsi);
	kfree(intel_connector);
}

Re: [cocci] Nested macros

[Julia Lawall]

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



On Sat, 28 Jan 2023, Luca Coelho wrote:

> On Fri, 2023-01-27 at 21:52 +0100, Julia Lawall wrote:
> >
> > On Fri, 27 Jan 2023, Luca Coelho wrote:
> >
> > > Hi,
> > >
> > > I've been struggling with a change I want to make, so I hope someone
> > > can help.
> > >
> > > Basically I have something like this in the code:
> > >
> > > /* regs below are bits 15:0 */
> > > #define _MIPIA_HSYNC_PADDING_COUNT     (_MIPI_MMIO_BASE(dev_priv) + 0xb028)
> > > #define _MIPIC_HSYNC_PADDING_COUNT     (_MIPI_MMIO_BASE(dev_priv) + 0xb828)
> > > #define MIPI_HSYNC_PADDING_COUNT(port) _MMIO_MIPI(port, _MIPIA_HSYNC_PADDING_COUNT, _MIPIC_HSYNC_PADDING_COUNT)
> > >
> > > As you can see, these macros assume that the calling functions have a
> > > local called dev_priv, and I want to fix that.
> > >
> > > So, I'm trying to find all users of macros that have this construct.
> > > My problem is matching the nesting in the macros.
> > >
> > > I have tried this:
> > >
> > > @macros_noargs@
> > > identifier m;
> > > expression e =~ "dev_priv";
> > > @@
> > > #define m <+...e...+>
> > >
> > > @nested_macros@
> > > identifier macros_noargs.m;
> > > identifier nm;
> > > @@
> > > #define nm(...) <+...m...+>
> > >
> > > @@
> > > identifier nested_macros.nm;
> > > @@
> > > -nm
> > > +foo
> > >
> > > (this last rule is just for testing if anything is matching, obviously)
> > >
> > > But the "nested_macros" rule doesn't seem to work.  Does anyone know
> > > how I can solve this?
> >
> > I think that it works already.  If you add the following code to the .c
> > file, then the call gets changed:
> >
> > int main() {
> >   MIPI_HSYNC_PADDING_COUNT(12);
> > }
> >
> > I think that the problem is that a rule that replaces an identifier by
> > another doesn't match a macro definition.  Is that actually the precise
> > thing you want to do?  Or do you want to do something with the uses of the
> > macro.
>
> This is the initial thing I want to do:
>
> @@
> identifier nested_macros.nm;
> function f;
> identifier dev_priv;
> expression e;
> @@
> f(...) {
> 	...
> -	struct drm_i915_private *dev_priv = e;
> +	struct drm_i915_private *i915 = e;
>
> 	<+...nm(...)...+>
> }
>
> And it indeed works with a handcrafted file for testing (attached as
> i915_cocci_test.c), but it doesn't work IRL, for instance in the
> drivers/gpu/drm/i915/display/vlv_dsi.c file in the kernel (also
> attached)...
>
> I would expect there to be a match in the static void
> bxt_dsi_get_pipe_config() function...

To match the function, the semantic patch has to be able to see the macro
definitions.  They are not in the .c file.  Maybe you need a command line
argument like --all-includes (take into account all of the files mentioned
with #include, but not what they include) or --recursive-includes.  You
can give a search path if needed with -I.

You can use --debug to get some information about what rules are being
matched successfully.

julia


>
>
> > If you want to change the definition, you can also add a rule like this:
> >
> > @@
> > identifier nested_macros.nm;
> > identifier list is;
> > expression e;
> > @@
> >
> > -#define nm(is) e
> > +#define foo(is) e
>
> This is not what I actually want to do, I just created the simplest
> rule I could come up with to actually see the match (and replacement)
> happening. 😉
>
> --
> Cheers,
> Luca.
>

Re: [cocci] Nested macros

[Luca Coelho]

On Sat, 2023-01-28 at 10:19 +0100, Julia Lawall wrote:
> 
> On Sat, 28 Jan 2023, Luca Coelho wrote:
> 
> > On Fri, 2023-01-27 at 21:52 +0100, Julia Lawall wrote:
> > > 
> > > On Fri, 27 Jan 2023, Luca Coelho wrote:
> > > 
> > > > Hi,
> > > > 
> > > > I've been struggling with a change I want to make, so I hope someone
> > > > can help.
> > > > 
> > > > Basically I have something like this in the code:
> > > > 
> > > > /* regs below are bits 15:0 */
> > > > #define _MIPIA_HSYNC_PADDING_COUNT     (_MIPI_MMIO_BASE(dev_priv) + 0xb028)
> > > > #define _MIPIC_HSYNC_PADDING_COUNT     (_MIPI_MMIO_BASE(dev_priv) + 0xb828)
> > > > #define MIPI_HSYNC_PADDING_COUNT(port) _MMIO_MIPI(port, _MIPIA_HSYNC_PADDING_COUNT, _MIPIC_HSYNC_PADDING_COUNT)
> > > > 
> > > > As you can see, these macros assume that the calling functions have a
> > > > local called dev_priv, and I want to fix that.
> > > > 
> > > > So, I'm trying to find all users of macros that have this construct.
> > > > My problem is matching the nesting in the macros.
> > > > 
> > > > I have tried this:
> > > > 
> > > > @macros_noargs@
> > > > identifier m;
> > > > expression e =~ "dev_priv";
> > > > @@
> > > > #define m <+...e...+>
> > > > 
> > > > @nested_macros@
> > > > identifier macros_noargs.m;
> > > > identifier nm;
> > > > @@
> > > > #define nm(...) <+...m...+>
> > > > 
> > > > @@
> > > > identifier nested_macros.nm;
> > > > @@
> > > > -nm
> > > > +foo
> > > > 
> > > > (this last rule is just for testing if anything is matching, obviously)
> > > > 
> > > > But the "nested_macros" rule doesn't seem to work.  Does anyone know
> > > > how I can solve this?
> > > 
> > > I think that it works already.  If you add the following code to the .c
> > > file, then the call gets changed:
> > > 
> > > int main() {
> > >   MIPI_HSYNC_PADDING_COUNT(12);
> > > }
> > > 
> > > I think that the problem is that a rule that replaces an identifier by
> > > another doesn't match a macro definition.  Is that actually the precise
> > > thing you want to do?  Or do you want to do something with the uses of the
> > > macro.
> > 
> > This is the initial thing I want to do:
> > 
> > @@
> > identifier nested_macros.nm;
> > function f;
> > identifier dev_priv;
> > expression e;
> > @@
> > f(...) {
> > 	...
> > -	struct drm_i915_private *dev_priv = e;
> > +	struct drm_i915_private *i915 = e;
> > 
> > 	<+...nm(...)...+>
> > }
> > 
> > And it indeed works with a handcrafted file for testing (attached as
> > i915_cocci_test.c), but it doesn't work IRL, for instance in the
> > drivers/gpu/drm/i915/display/vlv_dsi.c file in the kernel (also
> > attached)...
> > 
> > I would expect there to be a match in the static void
> > bxt_dsi_get_pipe_config() function...
> 
> To match the function, the semantic patch has to be able to see the macro
> definitions.  They are not in the .c file.  Maybe you need a command line
> argument like --all-includes (take into account all of the files mentioned
> with #include, but not what they include) or --recursive-includes.  You
> can give a search path if needed with -I.
> 
> You can use --debug to get some information about what rules are being
> matched successfully.

Thanks a lot, Julia! I'll try to play around with the includes.

--
Cheers,
Luca.

Re: [cocci] Searching for special function implementations with SmPL

[Markus Elfring]

> @@
> identifier nested_macros.nm;
> function f;
> identifier dev_priv;


How do you think about to use the following SmPL code variant instead of
the metavariable type “function”?


identifier dev_priv, f;



> expression e;
> @@
> f(...) {
> 	...
> -	struct drm_i915_private *dev_priv = e;
> +	struct drm_i915_private *i915 = e;
>
> 	<+...nm(...)...+>
> }

Regards,
Markus

Re: [cocci] Searching for special function implementations with SmPL

[Julia Lawall]

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



On Sat, 28 Jan 2023, Markus Elfring wrote:

> > @@
> > identifier nested_macros.nm;
> > function f;
> > identifier dev_priv;
>
>
> How do you think about to use the following SmPL code variant instead of
> the metavariable type “function”?
>
>
> identifier dev_priv, f;

Good suggestion,  Function is not really supported.  I think it behaves
just like identifier, but it would be better to just use identifier.
Function was an idea thta never actually got implemented.

julia

>
>
>
> > expression e;
> > @@
> > f(...) {
> > 	...
> > -	struct drm_i915_private *dev_priv = e;
> > +	struct drm_i915_private *i915 = e;
> >
> > 	<+...nm(...)...+>
> > }
>
> Regards,
> Markus
>

Re: [cocci] Searching for special function implementations with SmPL

[Luca Coelho]

On Sat, 2023-01-28 at 10:49 +0100, Julia Lawall wrote:
> 
> On Sat, 28 Jan 2023, Markus Elfring wrote:
> 
> > > @@
> > > identifier nested_macros.nm;
> > > function f;
> > > identifier dev_priv;
> > 
> > 
> > How do you think about to use the following SmPL code variant instead of
> > the metavariable type “function”?
> > 
> > 
> > identifier dev_priv, f;
> 
> Good suggestion,  Function is not really supported.  I think it behaves
> just like identifier, but it would be better to just use identifier.
> Function was an idea thta never actually got implemented.

Good idea, I generally don't use function, but I'd been trying lots of
different things before I reached out for help. 🙂 I guess I tried with
function at some point and then ended up leaving it there.

Now I tried with f as identifier, but it didn't make a difference.

I can actually match _one_ of the occurrences now, but there are many
other ones that are not matching...

This is what I'm using:

@macros_noargs@
identifier m;
expression e =~ "dev_priv";
@@
#define m <+...e...+>

@nested_macros@
identifier macros_noargs.m;
identifier nm;
@@
#define nm(...) <+...m...+>

@@
identifier nested_macros.nm;
identifier dev_priv, f;
expression e;
@@
f(...) {
	...
-	struct drm_i915_private *dev_priv = e;
+	struct drm_i915_private *i915 = e;

	<+...
	nm(...)
	...+>
}

...and this is the command line:

spatch --sp-file ~/dev_priv_i915.spatch -I drivers/gpu/drm/i915/display \
 --recursive-includes --in-place --dir ./drivers/gpu/drm/i915/display

...and this is the only match I get:

HANDLING: ./drivers/gpu/drm/i915/display/intel_display.c
diff = 
diff -u -p a/intel_display.c b/intel_display.c
--- a/intel_display.c
+++ b/intel_display.c
@@ -3943,7 +3943,7 @@ static bool bxt_get_dsi_transcoder_state
 					 struct intel_display_power_domain_set *power_domain_set)
 {
 	struct drm_device *dev = crtc->base.dev;
-	struct drm_i915_private *dev_priv = to_i915(dev);
+	struct drm_i915_private *i915 = to_i915(dev);
 	enum transcoder cpu_transcoder;
 	enum port port;
 	u32 tmp;

Many other files are handled, but there are no matches, though I
believe there should be.

--
Cheers,
Luca.

Re: [cocci] Searching for special function implementations with SmPL

[Julia Lawall]

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



On Sat, 28 Jan 2023, Luca Coelho wrote:

> On Sat, 2023-01-28 at 10:49 +0100, Julia Lawall wrote:
> >
> > On Sat, 28 Jan 2023, Markus Elfring wrote:
> >
> > > > @@
> > > > identifier nested_macros.nm;
> > > > function f;
> > > > identifier dev_priv;
> > >
> > >
> > > How do you think about to use the following SmPL code variant instead of
> > > the metavariable type “function”?
> > >
> > >
> > > identifier dev_priv, f;
> >
> > Good suggestion,  Function is not really supported.  I think it behaves
> > just like identifier, but it would be better to just use identifier.
> > Function was an idea thta never actually got implemented.
>
> Good idea, I generally don't use function, but I'd been trying lots of
> different things before I reached out for help. 🙂 I guess I tried with
> function at some point and then ended up leaving it there.
>
> Now I tried with f as identifier, but it didn't make a difference.
>
> I can actually match _one_ of the occurrences now, but there are many
> other ones that are not matching...
>
> This is what I'm using:
>
> @macros_noargs@
> identifier m;
> expression e =~ "dev_priv";
> @@
> #define m <+...e...+>
>
> @nested_macros@
> identifier macros_noargs.m;
> identifier nm;
> @@
> #define nm(...) <+...m...+>
>
> @@
> identifier nested_macros.nm;
> identifier dev_priv, f;
> expression e;
> @@
> f(...) {
> 	...
> -	struct drm_i915_private *dev_priv = e;
> +	struct drm_i915_private *i915 = e;
>
> 	<+...
> 	nm(...)
> 	...+>
> }
>
> ...and this is the command line:
>
> spatch --sp-file ~/dev_priv_i915.spatch -I drivers/gpu/drm/i915/display \
>  --recursive-includes --in-place --dir ./drivers/gpu/drm/i915/display
>
> ...and this is the only match I get:
>
> HANDLING: ./drivers/gpu/drm/i915/display/intel_display.c
> diff =
> diff -u -p a/intel_display.c b/intel_display.c
> --- a/intel_display.c
> +++ b/intel_display.c
> @@ -3943,7 +3943,7 @@ static bool bxt_get_dsi_transcoder_state
>  					 struct intel_display_power_domain_set *power_domain_set)
>  {
>  	struct drm_device *dev = crtc->base.dev;
> -	struct drm_i915_private *dev_priv = to_i915(dev);
> +	struct drm_i915_private *i915 = to_i915(dev);
>  	enum transcoder cpu_transcoder;
>  	enum port port;
>  	u32 tmp;
>
> Many other files are handled, but there are no matches, though I
> believe there should be.

Sorry, but it's not obvious how to debug this without any idea of what
should be found,  Maybe the proper macro definitions are not being found.
Maybe the proper uses are not being found.  Do you have a concrete example
where a change should happen?

thanks,
julia

Re: [cocci] Searching for special function implementations with SmPL

[Luca Coelho]

On Sat, 2023-01-28 at 14:33 +0100, Julia Lawall wrote:
> 
> On Sat, 28 Jan 2023, Luca Coelho wrote:
> 
> > On Sat, 2023-01-28 at 10:49 +0100, Julia Lawall wrote:
> > > 
> > > On Sat, 28 Jan 2023, Markus Elfring wrote:
> > > 
> > > > > @@
> > > > > identifier nested_macros.nm;
> > > > > function f;
> > > > > identifier dev_priv;
> > > > 
> > > > 
> > > > How do you think about to use the following SmPL code variant instead of
> > > > the metavariable type “function”?
> > > > 
> > > > 
> > > > identifier dev_priv, f;
> > > 
> > > Good suggestion,  Function is not really supported.  I think it behaves
> > > just like identifier, but it would be better to just use identifier.
> > > Function was an idea thta never actually got implemented.
> > 
> > Good idea, I generally don't use function, but I'd been trying lots of
> > different things before I reached out for help. 🙂 I guess I tried with
> > function at some point and then ended up leaving it there.
> > 
> > Now I tried with f as identifier, but it didn't make a difference.
> > 
> > I can actually match _one_ of the occurrences now, but there are many
> > other ones that are not matching...
> > 
> > This is what I'm using:
> > 
> > @macros_noargs@
> > identifier m;
> > expression e =~ "dev_priv";
> > @@
> > #define m <+...e...+>
> > 
> > @nested_macros@
> > identifier macros_noargs.m;
> > identifier nm;
> > @@
> > #define nm(...) <+...m...+>
> > 
> > @@
> > identifier nested_macros.nm;
> > identifier dev_priv, f;
> > expression e;
> > @@
> > f(...) {
> > 	...
> > -	struct drm_i915_private *dev_priv = e;
> > +	struct drm_i915_private *i915 = e;
> > 
> > 	<+...
> > 	nm(...)
> > 	...+>
> > }
> > 
> > ...and this is the command line:
> > 
> > spatch --sp-file ~/dev_priv_i915.spatch -I drivers/gpu/drm/i915/display \
> >  --recursive-includes --in-place --dir ./drivers/gpu/drm/i915/display
> > 
> > ...and this is the only match I get:
> > 
> > HANDLING: ./drivers/gpu/drm/i915/display/intel_display.c
> > diff =
> > diff -u -p a/intel_display.c b/intel_display.c
> > --- a/intel_display.c
> > +++ b/intel_display.c
> > @@ -3943,7 +3943,7 @@ static bool bxt_get_dsi_transcoder_state
> >  					 struct intel_display_power_domain_set *power_domain_set)
> >  {
> >  	struct drm_device *dev = crtc->base.dev;
> > -	struct drm_i915_private *dev_priv = to_i915(dev);
> > +	struct drm_i915_private *i915 = to_i915(dev);
> >  	enum transcoder cpu_transcoder;
> >  	enum port port;
> >  	u32 tmp;
> > 
> > Many other files are handled, but there are no matches, though I
> > believe there should be.
> 
> Sorry, but it's not obvious how to debug this without any idea of what
> should be found,  Maybe the proper macro definitions are not being found.
> Maybe the proper uses are not being found.  Do you have a concrete example
> where a change should happen?

Yes, sorry for not being clear enough.  The issue I'm trying to solve
is that we have bunch of macros, such as MIPI_CTRL(), that implicitly
uses dev_priv, so it must be declared as a local in the function
calling it.  I want to make this explicit, so I want to do exactly
this:


@macros_noargs@
identifier m;
expression e =~ "dev_priv";
@@
#define m <+...e...+>

@nested_macros@
identifier macros_noargs.m;
identifier nm;
identifier list il;
@@
#define nm(il) <+...m...+>

@@
identifier nested_macros.nm;
identifier list il;
expression e;
@@
-#define nm(il) e
+#define nm(dev_priv, il) e

@@
identifier nested_macros.nm;
identifier dev_priv, f;
expression e;
expression list il;
@@
f(...) {
	...
(
	struct drm_i915_private *dev_priv = e;
|
	struct drm_i915_private *dev_priv;
)

	<+...
-	nm(il)
+	nm(dev_priv, il)
	...+>
}


The idea is that all the macros that are implicitly using dev_priv,
will have a new argument where dev_priv is passed.

So, eg. in drivers/gpu/drm/i915/display/vlv_dsi.c, the following code:

static bool glk_dsi_enable_io(struct intel_encoder *encoder)
{
	struct drm_i915_private *dev_priv = to_i915(encoder-
>base.dev);
[...]
	for_each_dsi_port(port, intel_dsi->ports) {
		tmp = intel_de_read(dev_priv, MIPI_CTRL(port));
		intel_de_write(dev_priv, MIPI_CTRL(port),
			       tmp | GLK_MIPIIO_ENABLE);
	}
[...]
}

Would become:

static bool glk_dsi_enable_io(struct intel_encoder *encoder)
{
	struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
[...]
	for_each_dsi_port(port, intel_dsi->ports) {
		tmp = intel_de_read(dev_priv, MIPI_CTRL(dev_priv, port));
		intel_de_write(dev_priv, MIPI_CTRL(dev_priv, port),
			       tmp | GLK_MIPIIO_ENABLE);
	}
[...]
}


And the macro definition:

#define MIPI_CTRL(port)			_MMIO_MIPI(port, _MIPIA_CTRL, _MIPIC_CTRL)

Would become:

#define MIPI_CTRL(dev_priv,port) _MMIO_MIPI(port, _MIPIA_CTRL, _MIPIC_CTRL)


After mangling a lot with the rules, I can see that this now works, but
only if I select the vlv_dsi.c file alone, like this:

spatch --sp-file ~/dev_priv_i915.spatch -I drivers/gpu/drm/i915/display \
 --all-includes --in-place ./drivers/gpu/drm/i915/display/vlv_dsi.c


If I try to run the rules in all files in that directory, only the
intel_display.c file is affected:

spatch --sp-file ~/dev_priv_i915.spatch -I drivers/gpu/drm/i915/display  \
 --all-includes --in-place ./drivers/gpu/drm/i915/display


Of course, I can work around this by using find and running spatch
individually in every file... But not ideal.

--
Cheers,
Luca.

Re: [cocci] Searching for special function implementations with SmPL

[Julia Lawall]

> After mangling a lot with the rules, I can see that this now works, but
> only if I select the vlv_dsi.c file alone, like this:
>
> spatch --sp-file ~/dev_priv_i915.spatch -I drivers/gpu/drm/i915/display \
>  --all-includes --in-place ./drivers/gpu/drm/i915/display/vlv_dsi.c
>
>
> If I try to run the rules in all files in that directory, only the
> intel_display.c file is affected:
>
> spatch --sp-file ~/dev_priv_i915.spatch -I drivers/gpu/drm/i915/display  \
>  --all-includes --in-place ./drivers/gpu/drm/i915/display
>
>
> Of course, I can work around this by using find and running spatch
> individually in every file... But not ideal.

OK, so perhaps the problem is not actually the rules, but rather the way
in which the header files are being collected.

What version of Coccinelle do you have?  Someone (Kees?) reported a
problem with the collecion of header files at one point fairly recently,
and I think I fixed it.  It should be available in the github version of
Coccinelle.

julia

Re: [cocci] Searching for special function implementations with SmPL

[Luca Coelho]

On Sun, 2023-01-29 at 18:28 +0100, Julia Lawall wrote:
> > After mangling a lot with the rules, I can see that this now works,
> > but
> > only if I select the vlv_dsi.c file alone, like this:
> > 
> > spatch --sp-file ~/dev_priv_i915.spatch -I
> > drivers/gpu/drm/i915/display \
> >  --all-includes --in-place ./drivers/gpu/drm/i915/display/vlv_dsi.c
> > 
> > 
> > If I try to run the rules in all files in that directory, only the
> > intel_display.c file is affected:
> > 
> > spatch --sp-file ~/dev_priv_i915.spatch -I
> > drivers/gpu/drm/i915/display  \
> >  --all-includes --in-place ./drivers/gpu/drm/i915/display
> > 
> > 
> > Of course, I can work around this by using find and running spatch
> > individually in every file... But not ideal.
> 
> OK, so perhaps the problem is not actually the rules, but rather the
> way in which the header files are being collected.

Yeah, after banging my head on the rules, I realized that the rules
themselves were not really the issue.


> What version of Coccinelle do you have?  Someone (Kees?) reported a
> problem with the collecion of header files at one point fairly
> recently, and I think I fixed it.  It should be available in the
> github version of Coccinelle.

This is what I have:

luca@kveik:~/gfx/linux-drm-tip$ spatch --version
spatch version 1.1.1 compiled with OCaml version 4.13.1
Flags passed to the configure script: --prefix=/usr --sysconfdir=/etc --libdir=/usr/lib --enable-ocaml --enable-python --with-python=python3 --enable-opt
OCaml scripting support: yes
Python scripting support: yes
Syntax of regular expressions: PCRE

It's the standard one from Debian testing.

I'll try the github version.  Thanks for pointing out!

--
Cheers,
Luca.

Re: [cocci] Searching for special function implementations with SmPL

[Luca Coelho]

On Sun, 2023-01-29 at 19:55 +0200, Luca Coelho wrote:
> On Sun, 2023-01-29 at 18:28 +0100, Julia Lawall wrote:
> > > After mangling a lot with the rules, I can see that this now works,
> > > but
> > > only if I select the vlv_dsi.c file alone, like this:
> > > 
> > > spatch --sp-file ~/dev_priv_i915.spatch -I
> > > drivers/gpu/drm/i915/display \
> > >  --all-includes --in-place ./drivers/gpu/drm/i915/display/vlv_dsi.c
> > > 
> > > 
> > > If I try to run the rules in all files in that directory, only the
> > > intel_display.c file is affected:
> > > 
> > > spatch --sp-file ~/dev_priv_i915.spatch -I
> > > drivers/gpu/drm/i915/display  \
> > >  --all-includes --in-place ./drivers/gpu/drm/i915/display
> > > 
> > > 
> > > Of course, I can work around this by using find and running spatch
> > > individually in every file... But not ideal.
> > 
> > OK, so perhaps the problem is not actually the rules, but rather the
> > way in which the header files are being collected.
> 
> Yeah, after banging my head on the rules, I realized that the rules
> themselves were not really the issue.
> 
> 
> > What version of Coccinelle do you have?  Someone (Kees?) reported a
> > problem with the collecion of header files at one point fairly
> > recently, and I think I fixed it.  It should be available in the
> > github version of Coccinelle.
> 
> This is what I have:
> 
> luca@kveik:~/gfx/linux-drm-tip$ spatch --version
> spatch version 1.1.1 compiled with OCaml version 4.13.1
> Flags passed to the configure script: --prefix=/usr --sysconfdir=/etc --libdir=/usr/lib --enable-ocaml --enable-python --with-python=python3 --enable-opt
> OCaml scripting support: yes
> Python scripting support: yes
> Syntax of regular expressions: PCRE
> 
> It's the standard one from Debian testing.
> 
> I'll try the github version.  Thanks for pointing out!

It seems to be working slightly better, but it's still not finding all
the occurrences that I find by calling spatch with all the files
individually... :( I tried the latest head from github,
87350d742df39d847b15af39865329c2fe23460d.

--
Cheers,
Luca.

Re: [cocci] Searching for special function implementations with SmPL

[Julia Lawall]

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



On Sun, 29 Jan 2023, Luca Coelho wrote:

> On Sun, 2023-01-29 at 19:55 +0200, Luca Coelho wrote:
> > On Sun, 2023-01-29 at 18:28 +0100, Julia Lawall wrote:
> > > > After mangling a lot with the rules, I can see that this now works,
> > > > but
> > > > only if I select the vlv_dsi.c file alone, like this:
> > > >
> > > > spatch --sp-file ~/dev_priv_i915.spatch -I
> > > > drivers/gpu/drm/i915/display \
> > > >  --all-includes --in-place ./drivers/gpu/drm/i915/display/vlv_dsi.c
> > > >
> > > >
> > > > If I try to run the rules in all files in that directory, only the
> > > > intel_display.c file is affected:
> > > >
> > > > spatch --sp-file ~/dev_priv_i915.spatch -I
> > > > drivers/gpu/drm/i915/display  \
> > > >  --all-includes --in-place ./drivers/gpu/drm/i915/display
> > > >
> > > >
> > > > Of course, I can work around this by using find and running spatch
> > > > individually in every file... But not ideal.
> > >
> > > OK, so perhaps the problem is not actually the rules, but rather the
> > > way in which the header files are being collected.
> >
> > Yeah, after banging my head on the rules, I realized that the rules
> > themselves were not really the issue.
> >
> >
> > > What version of Coccinelle do you have?  Someone (Kees?) reported a
> > > problem with the collecion of header files at one point fairly
> > > recently, and I think I fixed it.  It should be available in the
> > > github version of Coccinelle.
> >
> > This is what I have:
> >
> > luca@kveik:~/gfx/linux-drm-tip$ spatch --version
> > spatch version 1.1.1 compiled with OCaml version 4.13.1
> > Flags passed to the configure script: --prefix=/usr --sysconfdir=/etc --libdir=/usr/lib --enable-ocaml --enable-python --with-python=python3 --enable-opt
> > OCaml scripting support: yes
> > Python scripting support: yes
> > Syntax of regular expressions: PCRE
> >
> > It's the standard one from Debian testing.
> >
> > I'll try the github version.  Thanks for pointing out!
>
> It seems to be working slightly better, but it's still not finding all
> the occurrences that I find by calling spatch with all the files
> individually... :( I tried the latest head from github,
> 87350d742df39d847b15af39865329c2fe23460d.

Could you give a specific case that idn't found?

thanks,
julia


>
> --
> Cheers,
> Luca.
>

Re: [cocci] Searching for special function implementations with SmPL

[Luca Coelho]

On Sun, 2023-01-29 at 21:09 +0100, Julia Lawall wrote:
> On Sun, 29 Jan 2023, Luca Coelho wrote:
> > On Sun, 2023-01-29 at 19:55 +0200, Luca Coelho wrote:
> > > On Sun, 2023-01-29 at 18:28 +0100, Julia Lawall wrote:
> > > > 
> > > > What version of Coccinelle do you have?  Someone (Kees?) reported a
> > > > problem with the collecion of header files at one point fairly
> > > > recently, and I think I fixed it.  It should be available in the
> > > > github version of Coccinelle.
> > > 
> > > This is what I have:
> > > 
> > > luca@kveik:~/gfx/linux-drm-tip$ spatch --version
> > > spatch version 1.1.1 compiled with OCaml version 4.13.1
> > > Flags passed to the configure script: --prefix=/usr --sysconfdir=/etc --libdir=/usr/lib --enable-ocaml --enable-python --with-python=python3 --enable-opt
> > > OCaml scripting support: yes
> > > Python scripting support: yes
> > > Syntax of regular expressions: PCRE
> > > 
> > > It's the standard one from Debian testing.
> > > 
> > > I'll try the github version.  Thanks for pointing out!
> > 
> > It seems to be working slightly better, but it's still not finding all
> > the occurrences that I find by calling spatch with all the files
> > individually... :( I tried the latest head from github,
> > 87350d742df39d847b15af39865329c2fe23460d.
> 
> Could you give a specific case that idn't found?

Sorry, false alarm.  I was running spatch by itself on an inner
directory (.../i915/display), but when I used find, I was using
.../i915, so there was one more match happening there.

So, it seems that the latest head _does_ work fine! And I'm gettign all
the matches and changes that I expect.  Thanks!

I really appreciate your promptness in responding and helping with all
this.  I will probably come back with more questions soon, when I start
trying other rules. 🙂

--
Cheers,
Luca.

Re: [cocci] Searching for special function implementations with SmPL

[Julia Lawall]

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

> Sorry, false alarm.  I was running spatch by itself on an inner
> directory (.../i915/display), but when I used find, I was using
> .../i915, so there was one more match happening there.
>
> So, it seems that the latest head _does_ work fine! And I'm gettign all
> the matches and changes that I expect.  Thanks!

Great news :)

julia

>
> I really appreciate your promptness in responding and helping with all
> this.  I will probably come back with more questions soon, when I start
> trying other rules. 🙂
>
> --
> Cheers,
> Luca.
>

Re: [cocci] Searching for special function implementations with SmPL

[Luca Coelho]

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

On Mon, 2023-01-30 at 09:37 +0100, Julia Lawall wrote:
> > Sorry, false alarm.  I was running spatch by itself on an inner
> > directory (.../i915/display), but when I used find, I was using
> > .../i915, so there was one more match happening there.
> > 
> > So, it seems that the latest head _does_ work fine! And I'm gettign
> > all
> > the matches and changes that I expect.  Thanks!
> 
> Great news :)

Maybe I celebrated a bit too early.  There is still one instance that
is not matching...

I currently have these rules:

@macros_noargs@
identifier m;
expression e =~ "dev_priv";
@@
#define m <+...e...+>

@nested_macros@
identifier macros_noargs.m;
identifier nm;
identifier list il;
@@
#define nm(il) <+...m...+>

@@
identifier nested_macros.nm;
identifier dev_priv, f;
expression list el;
@@
f(...) {
	...
	struct drm_i915_private *dev_priv = ...;

	<+...
	nm(
+	dev_priv,	
	el)
	...+>
}

@@
identifier nested_macros.nm;
identifier dev_priv, f;
expression list el;
@@
f(..., struct drm_i915_private *dev_priv, ...) {
	<+...
	nm(
+	dev_priv,
	el)
	...+>
}

And then we have this function in
drivers/gpu/drm/i915/display/intel_display.c:

void vlv_wait_port_ready(struct drm_i915_private *dev_priv,
			 struct intel_digital_port *dig_port,
			 unsigned int expected_mask)
{
[...]
	switch (dig_port->base.port) {
	default:
		MISSING_CASE(dig_port->base.port);
		fallthrough;
	case PORT_B:
		port_mask = DPLL_PORTB_READY_MASK;
		dpll_reg = DPLL(0);
		break;
	case PORT_C:
		port_mask = DPLL_PORTC_READY_MASK;
		dpll_reg = DPLL(0);
		expected_mask <<= 4;
		break;
[...]
}

The DPLL macro is defined like this (in
drivers/gpu/drm/i915/display/i915_reg.h):

#define _DPLL_A (DISPLAY_MMIO_BASE(dev_priv) + 0x6014)
#define _DPLL_B (DISPLAY_MMIO_BASE(dev_priv) + 0x6018)
#define _CHV_DPLL_C (DISPLAY_MMIO_BASE(dev_priv) + 0x6030)
#define DPLL(pipe) _MMIO_PIPE3((pipe), _DPLL_A, _DPLL_B, _CHV_DPLL_C)


So it should match like the other instances, but it doesn't.  I copied
the macro definition and the function to stand-alone files (i.e.
without the rest of the code) and it matches, but in the real code,
running cocci like this, it doesn't:

~/public/coccinelle/spatch.opt --sp-file ~/dev_priv_i915.spatch --all-includes intel_display.c

I noticed some parsing errors when using --debug (output attached), so
maybe there's some parsing issues with the real file that prevents the
rule from applying?

Any clues?

--
Cheers,
Luca.

[-- Attachment #2: output.txt --]
[-- Type: text/plain, Size: 78833 bytes --]

init_defs_builtins: /home/luca/public/coccinelle/standard.h
-----------------------------------------------------------------------
processing semantic patch file: /home/luca/dev_priv_i915.spatch
with isos from: /home/luca/public/coccinelle/standard.iso
-----------------------------------------------------------------------
@macros_noargs@
identifier m;
expression e =~ "dev_priv";
@@
#define m <+...e...+>

@nested_macros@
identifier macros_noargs.m;
identifier nm;
identifier list il;
@@
#define nm(il) <+...m...+>

@@
identifier nested_macros.nm;
identifier dev_priv, f;
expression list el;
@@
f(...) {
	...
	struct drm_i915_private *dev_priv = ...;

	<+...
	nm(
+	dev_priv,	
	el)
	...+>
}

@@
identifier nested_macros.nm;
identifier dev_priv, f;
expression list el;
@@
f(..., struct drm_i915_private *dev_priv, ...) {
	<+...
	nm(
+	dev_priv,
	el)
	...+>
}

HANDLING: intel_display.c
-----------------------------------------------------------------------
let's go
-----------------------------------------------------------------------
-----------------------------------------------------------------------
ERROR-RECOV: found sync end of #define, line 162
parsing pass2: try again
ERROR-RECOV: found sync end of #define, line 162
parse error 
 = File "./intel_display_power.h", line 162, column 51, charpos = 4051
  around = '',
  whole content = 		for_each_if(test_bit((__domain), (__mask)->bits))
badcount: 4
bad: };
bad: 
bad: #define for_each_power_domain(__domain, __mask)				\
bad: 	for ((__domain) = 0; (__domain) < POWER_DOMAIN_NUM; (__domain)++)	\
BAD:!!!!! 		for_each_if(test_bit((__domain), (__mask)->bits))
ERROR-RECOV: found sync end of #define, line 282
parsing pass2: try again
ERROR-RECOV: found sync end of #define, line 282
parse error 
 = File "./intel_display_power.h", line 282, column 70, charpos = 8858
  around = '',
  whole content = 	     intel_display_power_put_async((i915), (domain), (wf)), (wf) = 0)
badcount: 4
bad: 			     u8 req_slices);
bad: 
bad: #define with_intel_display_power(i915, domain, wf) \
bad: 	for ((wf) = intel_display_power_get((i915), (domain)); (wf); \
BAD:!!!!! 	     intel_display_power_put_async((i915), (domain), (wf)), (wf) = 0)
ERROR-RECOV: found sync end of #define, line 286
parsing pass2: try again
ERROR-RECOV: found sync end of #define, line 286
parse error 
 = File "./intel_display_power.h", line 286, column 70, charpos = 9069
  around = '',
  whole content = 	     intel_display_power_put_async((i915), (domain), (wf)), (wf) = 0)
badcount: 4
bad: 	     intel_display_power_put_async((i915), (domain), (wf)), (wf) = 0)
bad: 
bad: #define with_intel_display_power_if_enabled(i915, domain, wf) \
bad: 	for ((wf) = intel_display_power_get_if_enabled((i915), (domain)); (wf); \
BAD:!!!!! 	     intel_display_power_put_async((i915), (domain), (wf)), (wf) = 0)
ERROR-RECOV: found sync end of #define, line 24
parsing pass2: try again
ERROR-RECOV: found sync end of #define, line 24
parse error 
 = File "./intel_pps.h", line 24, column 75, charpos = 574
  around = '',
  whole content = 	for ((wf) = intel_pps_lock(dp); (wf); (wf) = intel_pps_unlock((dp), (wf)))
badcount: 3
bad: intel_wakeref_t intel_pps_unlock(struct intel_dp *intel_dp, intel_wakeref_t wakeref);
bad: 
bad: #define with_intel_pps_lock(dp, wf)						\
BAD:!!!!! 	for ((wf) = intel_pps_lock(dp); (wf); (wf) = intel_pps_unlock((dp), (wf)))
ERROR-RECOV: found sync '}' at line 3711
parsing pass2: try again
ERROR-RECOV: found sync '}' at line 3711
parsing pass3: try again
ERROR-RECOV: found sync '}' at line 3711
parse error 
 = File "intel_display.c", line 3708, column 2, charpos = 111316
  around = 'tmp',
  whole content = 		tmp = intel_de_read(dev_priv, TRANS_DDI_FUNC_CTL(cpu_transcoder));
badcount: 15
bad: }
bad: 
bad: static bool transcoder_ddi_func_is_enabled(struct drm_i915_private *dev_priv,
bad: 					   enum transcoder cpu_transcoder)
bad: {
bad: 	enum intel_display_power_domain power_domain;
bad: 	intel_wakeref_t wakeref;
bad: 	u32 tmp = 0;
bad: 
bad: 	power_domain = POWER_DOMAIN_TRANSCODER(cpu_transcoder);
bad: 
bad: 	with_intel_display_power_if_enabled(dev_priv, power_domain, wakeref)
BAD:!!!!! 		tmp = intel_de_read(dev_priv, TRANS_DDI_FUNC_CTL(cpu_transcoder));
bad: 
bad: 	return tmp & TRANS_DDI_FUNC_ENABLE;
bad: }
ERROR-RECOV: found sync '}' at line 3758
parsing pass2: try again
ERROR-RECOV: found sync '}' at line 3758
parsing pass3: try again
ERROR-RECOV: found sync '}' at line 3758
parse error 
 = File "intel_display.c", line 3728, column 71, charpos = 111947
  around = '{',
  whole content = 		with_intel_display_power_if_enabled(dev_priv, power_domain, wakeref) {
badcount: 47
bad: }
bad: 
bad: static void enabled_bigjoiner_pipes(struct drm_i915_private *dev_priv,
bad: 				    u8 *master_pipes, u8 *slave_pipes)
bad: {
bad: 	struct intel_crtc *crtc;
bad: 
bad: 	*master_pipes = 0;
bad: 	*slave_pipes = 0;
bad: 
bad: 	for_each_intel_crtc_in_pipe_mask(&dev_priv->drm, crtc,
bad: 					 bigjoiner_pipes(dev_priv)) {
bad: 		enum intel_display_power_domain power_domain;
bad: 		enum pipe pipe = crtc->pipe;
bad: 		intel_wakeref_t wakeref;
bad: 
bad: 		power_domain = intel_dsc_power_domain(crtc, (enum transcoder) pipe);
BAD:!!!!! 		with_intel_display_power_if_enabled(dev_priv, power_domain, wakeref) {
bad: 			u32 tmp = intel_de_read(dev_priv, ICL_PIPE_DSS_CTL1(pipe));
bad: 
bad: 			if (!(tmp & BIG_JOINER_ENABLE))
bad: 				continue;
bad: 
bad: 			if (tmp & MASTER_BIG_JOINER_ENABLE)
bad: 				*master_pipes |= BIT(pipe);
bad: 			else
bad: 				*slave_pipes |= BIT(pipe);
bad: 		}
bad: 
bad: 		if (DISPLAY_VER(dev_priv) < 13)
bad: 			continue;
bad: 
bad: 		power_domain = POWER_DOMAIN_PIPE(pipe);
bad: 		with_intel_display_power_if_enabled(dev_priv, power_domain, wakeref) {
bad: 			u32 tmp = intel_de_read(dev_priv, ICL_PIPE_DSS_CTL1(pipe));
bad: 
bad: 			if (tmp & UNCOMPRESSED_JOINER_MASTER)
bad: 				*master_pipes |= BIT(pipe);
bad: 			if (tmp & UNCOMPRESSED_JOINER_SLAVE)
bad: 				*slave_pipes |= BIT(pipe);
bad: 		}
bad: 	}
bad: 
bad: 	/* Bigjoiner pipes should always be consecutive master and slave */
bad: 	drm_WARN(&dev_priv->drm, *slave_pipes != *master_pipes << 1,
bad: 		 "Bigjoiner misconfigured (master pipes 0x%x, slave pipes 0x%x)\n",
bad: 		 *master_pipes, *slave_pipes);
bad: }
ERROR-RECOV: found sync '}' at line 3868
parsing pass2: try again
ERROR-RECOV: found sync '}' at line 3868
parsing pass3: try again
ERROR-RECOV: found sync '}' at line 3868
parse error 
 = File "intel_display.c", line 3823, column 3, charpos = 114767
  around = 'tmp',
  whole content = 			tmp = intel_de_read(dev_priv, TRANS_DDI_FUNC_CTL(cpu_transcoder));
badcount: 69
bad: }
bad: 
bad: static u8 hsw_enabled_transcoders(struct intel_crtc *crtc)
bad: {
bad: 	struct drm_device *dev = crtc->base.dev;
bad: 	struct drm_i915_private *dev_priv = to_i915(dev);
bad: 	u8 panel_transcoder_mask = hsw_panel_transcoders(dev_priv);
bad: 	enum transcoder cpu_transcoder;
bad: 	u8 master_pipes, slave_pipes;
bad: 	u8 enabled_transcoders = 0;
bad: 
bad: 	/*
bad: 	 * XXX: Do intel_display_power_get_if_enabled before reading this (for
bad: 	 * consistency and less surprising code; it's in always on power).
bad: 	 */
bad: 	for_each_cpu_transcoder_masked(dev_priv, cpu_transcoder,
bad: 				       panel_transcoder_mask) {
bad: 		enum intel_display_power_domain power_domain;
bad: 		intel_wakeref_t wakeref;
bad: 		enum pipe trans_pipe;
bad: 		u32 tmp = 0;
bad: 
bad: 		power_domain = POWER_DOMAIN_TRANSCODER(cpu_transcoder);
bad: 		with_intel_display_power_if_enabled(dev_priv, power_domain, wakeref)
BAD:!!!!! 			tmp = intel_de_read(dev_priv, TRANS_DDI_FUNC_CTL(cpu_transcoder));
bad: 
bad: 		if (!(tmp & TRANS_DDI_FUNC_ENABLE))
bad: 			continue;
bad: 
bad: 		switch (tmp & TRANS_DDI_EDP_INPUT_MASK) {
bad: 		default:
bad: 			drm_WARN(dev, 1,
bad: 				 "unknown pipe linked to transcoder %s\n",
bad: 				 transcoder_name(cpu_transcoder));
bad: 			fallthrough;
bad: 		case TRANS_DDI_EDP_INPUT_A_ONOFF:
bad: 		case TRANS_DDI_EDP_INPUT_A_ON:
bad: 			trans_pipe = PIPE_A;
bad: 			break;
bad: 		case TRANS_DDI_EDP_INPUT_B_ONOFF:
bad: 			trans_pipe = PIPE_B;
bad: 			break;
bad: 		case TRANS_DDI_EDP_INPUT_C_ONOFF:
bad: 			trans_pipe = PIPE_C;
bad: 			break;
bad: 		case TRANS_DDI_EDP_INPUT_D_ONOFF:
bad: 			trans_pipe = PIPE_D;
bad: 			break;
bad: 		}
bad: 
bad: 		if (trans_pipe == crtc->pipe)
bad: 			enabled_transcoders |= BIT(cpu_transcoder);
bad: 	}
bad: 
bad: 	/* single pipe or bigjoiner master */
bad: 	cpu_transcoder = (enum transcoder) crtc->pipe;
bad: 	if (transcoder_ddi_func_is_enabled(dev_priv, cpu_transcoder))
bad: 		enabled_transcoders |= BIT(cpu_transcoder);
bad: 
bad: 	/* bigjoiner slave -> consider the master pipe's transcoder as well */
bad: 	enabled_bigjoiner_pipes(dev_priv, &master_pipes, &slave_pipes);
bad: 	if (slave_pipes & BIT(crtc->pipe)) {
bad: 		cpu_transcoder = (enum transcoder)
bad: 			get_bigjoiner_master_pipe(crtc->pipe, master_pipes, slave_pipes);
bad: 		if (transcoder_ddi_func_is_enabled(dev_priv, cpu_transcoder))
bad: 			enabled_transcoders |= BIT(cpu_transcoder);
bad: 	}
bad: 
bad: 	return enabled_transcoders;
bad: }
(ONCE) ast_to_flow: filter a directive
-----------------------------------------------------------------------
macros_noargs = 
-----------------------------------------------------------------------
dependencies for rule macros_noargs satisfied:
binding in = []
binding relevant in = []
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIA_DEVICE_READY]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIC_DEVICE_READY]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIA_INTR_STAT]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIC_INTR_STAT]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIA_INTR_EN]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIC_INTR_EN]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIA_DSI_FUNC_PRG]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIC_DSI_FUNC_PRG]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIA_HS_TX_TIMEOUT]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIC_HS_TX_TIMEOUT]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIA_LP_RX_TIMEOUT]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIC_LP_RX_TIMEOUT]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIA_TURN_AROUND_TIMEOUT]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIC_TURN_AROUND_TIMEOUT]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIA_DEVICE_RESET_TIMER]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIC_DEVICE_RESET_TIMER]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIA_DPI_RESOLUTION]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIC_DPI_RESOLUTION]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIA_DBI_FIFO_THROTTLE]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIC_DBI_FIFO_THROTTLE]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIA_HSYNC_PADDING_COUNT]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIC_HSYNC_PADDING_COUNT]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIA_HBP_COUNT]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIC_HBP_COUNT]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIA_HFP_COUNT]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIC_HFP_COUNT]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIA_HACTIVE_AREA_COUNT]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIC_HACTIVE_AREA_COUNT]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIA_VSYNC_PADDING_COUNT]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIC_VSYNC_PADDING_COUNT]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIA_VBP_COUNT]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIC_VBP_COUNT]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIA_VFP_COUNT]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIC_VFP_COUNT]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIA_HIGH_LOW_SWITCH_COUNT]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIC_HIGH_LOW_SWITCH_COUNT]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIA_DPI_CONTROL]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIC_DPI_CONTROL]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIA_DPI_DATA]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIC_DPI_DATA]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIA_INIT_COUNT]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIC_INIT_COUNT]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIA_MAX_RETURN_PKT_SIZE]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIC_MAX_RETURN_PKT_SIZE]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIA_VIDEO_MODE_FORMAT]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIC_VIDEO_MODE_FORMAT]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIA_EOT_DISABLE]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIC_EOT_DISABLE]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIA_LP_BYTECLK]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIC_LP_BYTECLK]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIA_TLPX_TIME_COUNT]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIC_TLPX_TIME_COUNT]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIA_CLK_LANE_TIMING]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIC_CLK_LANE_TIMING]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIA_LP_GEN_DATA]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIC_LP_GEN_DATA]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIA_HS_GEN_DATA]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIC_HS_GEN_DATA]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIA_LP_GEN_CTRL]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIC_LP_GEN_CTRL]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIA_HS_GEN_CTRL]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIC_HS_GEN_CTRL]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIA_GEN_FIFO_STAT]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIC_GEN_FIFO_STAT]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIA_HS_LS_DBI_ENABLE]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIC_HS_LS_DBI_ENABLE]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIA_DPHY_PARAM]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIC_DPHY_PARAM]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIA_DBI_BW_CTRL]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIC_DBI_BW_CTRL]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIA_CLK_LANE_SWITCH_TIME_CNT]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIC_CLK_LANE_SWITCH_TIME_CNT]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIA_STOP_STATE_STALL]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIC_STOP_STATE_STALL]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIA_INTR_STAT_REG_1]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIC_INTR_STAT_REG_1]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIA_INTR_EN_REG_1]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIC_INTR_EN_REG_1]
     transformation info is empty
     binding out = [macros_noargs.m --> id MIPIA_DBI_TYPEC_CTRL]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIA_CTRL]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIC_CTRL]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIA_DATA_ADDRESS]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIC_DATA_ADDRESS]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIA_DATA_LENGTH]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIC_DATA_LENGTH]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIA_COMMAND_ADDRESS]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIC_COMMAND_ADDRESS]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIA_COMMAND_LENGTH]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIC_COMMAND_LENGTH]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIA_READ_DATA_RETURN0]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIC_READ_DATA_RETURN0]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIA_READ_DATA_VALID]
     transformation info is empty
     binding out = [macros_noargs.m --> id _MIPIC_READ_DATA_VALID]
-----------------------------------------------------------------------
nested_macros = 
-----------------------------------------------------------------------
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id MIPIA_DBI_TYPEC_CTRL]
binding relevant in = [macros_noargs.m --> id MIPIA_DBI_TYPEC_CTRL]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIA_CLK_LANE_SWITCH_TIME_CNT]
binding relevant in = [macros_noargs.m --> id _MIPIA_CLK_LANE_SWITCH_TIME_CNT]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_CLK_LANE_SWITCH_TIME_CNT]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIA_CLK_LANE_TIMING]
binding relevant in = [macros_noargs.m --> id _MIPIA_CLK_LANE_TIMING]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_CLK_LANE_TIMING]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIA_COMMAND_ADDRESS]
binding relevant in = [macros_noargs.m --> id _MIPIA_COMMAND_ADDRESS]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_COMMAND_ADDRESS]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIA_COMMAND_LENGTH]
binding relevant in = [macros_noargs.m --> id _MIPIA_COMMAND_LENGTH]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_COMMAND_LENGTH]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIA_CTRL]
binding relevant in = [macros_noargs.m --> id _MIPIA_CTRL]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_CTRL]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIA_DATA_ADDRESS]
binding relevant in = [macros_noargs.m --> id _MIPIA_DATA_ADDRESS]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_DATA_ADDRESS]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIA_DATA_LENGTH]
binding relevant in = [macros_noargs.m --> id _MIPIA_DATA_LENGTH]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_DATA_LENGTH]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIA_DBI_BW_CTRL]
binding relevant in = [macros_noargs.m --> id _MIPIA_DBI_BW_CTRL]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_DBI_BW_CTRL]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIA_DBI_FIFO_THROTTLE]
binding relevant in = [macros_noargs.m --> id _MIPIA_DBI_FIFO_THROTTLE]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_DBI_FIFO_THROTTLE]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIA_DEVICE_READY]
binding relevant in = [macros_noargs.m --> id _MIPIA_DEVICE_READY]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_DEVICE_READY]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIA_DEVICE_RESET_TIMER]
binding relevant in = [macros_noargs.m --> id _MIPIA_DEVICE_RESET_TIMER]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_DEVICE_RESET_TIMER]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIA_DPHY_PARAM]
binding relevant in = [macros_noargs.m --> id _MIPIA_DPHY_PARAM]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_DPHY_PARAM]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIA_DPI_CONTROL]
binding relevant in = [macros_noargs.m --> id _MIPIA_DPI_CONTROL]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_DPI_CONTROL]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIA_DPI_DATA]
binding relevant in = [macros_noargs.m --> id _MIPIA_DPI_DATA]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_DPI_DATA]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIA_DPI_RESOLUTION]
binding relevant in = [macros_noargs.m --> id _MIPIA_DPI_RESOLUTION]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_DPI_RESOLUTION]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIA_DSI_FUNC_PRG]
binding relevant in = [macros_noargs.m --> id _MIPIA_DSI_FUNC_PRG]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_DSI_FUNC_PRG]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIA_EOT_DISABLE]
binding relevant in = [macros_noargs.m --> id _MIPIA_EOT_DISABLE]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_EOT_DISABLE]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIA_GEN_FIFO_STAT]
binding relevant in = [macros_noargs.m --> id _MIPIA_GEN_FIFO_STAT]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_GEN_FIFO_STAT]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIA_HACTIVE_AREA_COUNT]
binding relevant in = [macros_noargs.m --> id _MIPIA_HACTIVE_AREA_COUNT]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_HACTIVE_AREA_COUNT]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIA_HBP_COUNT]
binding relevant in = [macros_noargs.m --> id _MIPIA_HBP_COUNT]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_HBP_COUNT]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIA_HFP_COUNT]
binding relevant in = [macros_noargs.m --> id _MIPIA_HFP_COUNT]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_HFP_COUNT]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIA_HIGH_LOW_SWITCH_COUNT]
binding relevant in = [macros_noargs.m --> id _MIPIA_HIGH_LOW_SWITCH_COUNT]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_HIGH_LOW_SWITCH_COUNT]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIA_HSYNC_PADDING_COUNT]
binding relevant in = [macros_noargs.m --> id _MIPIA_HSYNC_PADDING_COUNT]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_HSYNC_PADDING_COUNT]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIA_HS_GEN_CTRL]
binding relevant in = [macros_noargs.m --> id _MIPIA_HS_GEN_CTRL]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_HS_GEN_CTRL]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIA_HS_GEN_DATA]
binding relevant in = [macros_noargs.m --> id _MIPIA_HS_GEN_DATA]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_HS_GEN_DATA]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIA_HS_LS_DBI_ENABLE]
binding relevant in = [macros_noargs.m --> id _MIPIA_HS_LS_DBI_ENABLE]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_HS_LP_DBI_ENABLE]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIA_HS_TX_TIMEOUT]
binding relevant in = [macros_noargs.m --> id _MIPIA_HS_TX_TIMEOUT]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_HS_TX_TIMEOUT]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIA_INIT_COUNT]
binding relevant in = [macros_noargs.m --> id _MIPIA_INIT_COUNT]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_INIT_COUNT]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIA_INTR_EN]
binding relevant in = [macros_noargs.m --> id _MIPIA_INTR_EN]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_INTR_EN]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIA_INTR_EN_REG_1]
binding relevant in = [macros_noargs.m --> id _MIPIA_INTR_EN_REG_1]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_INTR_EN_REG_1]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIA_INTR_STAT]
binding relevant in = [macros_noargs.m --> id _MIPIA_INTR_STAT]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_INTR_STAT]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIA_INTR_STAT_REG_1]
binding relevant in = [macros_noargs.m --> id _MIPIA_INTR_STAT_REG_1]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_INTR_STAT_REG_1]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIA_LP_BYTECLK]
binding relevant in = [macros_noargs.m --> id _MIPIA_LP_BYTECLK]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_LP_BYTECLK]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIA_LP_GEN_CTRL]
binding relevant in = [macros_noargs.m --> id _MIPIA_LP_GEN_CTRL]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_LP_GEN_CTRL]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIA_LP_GEN_DATA]
binding relevant in = [macros_noargs.m --> id _MIPIA_LP_GEN_DATA]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_LP_GEN_DATA]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIA_LP_RX_TIMEOUT]
binding relevant in = [macros_noargs.m --> id _MIPIA_LP_RX_TIMEOUT]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_LP_RX_TIMEOUT]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIA_MAX_RETURN_PKT_SIZE]
binding relevant in = [macros_noargs.m --> id _MIPIA_MAX_RETURN_PKT_SIZE]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_MAX_RETURN_PKT_SIZE]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIA_READ_DATA_RETURN0]
binding relevant in = [macros_noargs.m --> id _MIPIA_READ_DATA_RETURN0]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_READ_DATA_RETURN]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIA_READ_DATA_VALID]
binding relevant in = [macros_noargs.m --> id _MIPIA_READ_DATA_VALID]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_READ_DATA_VALID]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIA_STOP_STATE_STALL]
binding relevant in = [macros_noargs.m --> id _MIPIA_STOP_STATE_STALL]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_STOP_STATE_STALL]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIA_TLPX_TIME_COUNT]
binding relevant in = [macros_noargs.m --> id _MIPIA_TLPX_TIME_COUNT]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_TLPX_TIME_COUNT]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIA_TURN_AROUND_TIMEOUT]
binding relevant in = [macros_noargs.m --> id _MIPIA_TURN_AROUND_TIMEOUT]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_TURN_AROUND_TIMEOUT]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIA_VBP_COUNT]
binding relevant in = [macros_noargs.m --> id _MIPIA_VBP_COUNT]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_VBP_COUNT]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIA_VFP_COUNT]
binding relevant in = [macros_noargs.m --> id _MIPIA_VFP_COUNT]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_VFP_COUNT]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIA_VIDEO_MODE_FORMAT]
binding relevant in = [macros_noargs.m --> id _MIPIA_VIDEO_MODE_FORMAT]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_VIDEO_MODE_FORMAT]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIA_VSYNC_PADDING_COUNT]
binding relevant in = [macros_noargs.m --> id _MIPIA_VSYNC_PADDING_COUNT]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_VSYNC_PADDING_COUNT]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIC_CLK_LANE_SWITCH_TIME_CNT]
binding relevant in = [macros_noargs.m --> id _MIPIC_CLK_LANE_SWITCH_TIME_CNT]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_CLK_LANE_SWITCH_TIME_CNT]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIC_CLK_LANE_TIMING]
binding relevant in = [macros_noargs.m --> id _MIPIC_CLK_LANE_TIMING]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_CLK_LANE_TIMING]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIC_COMMAND_ADDRESS]
binding relevant in = [macros_noargs.m --> id _MIPIC_COMMAND_ADDRESS]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_COMMAND_ADDRESS]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIC_COMMAND_LENGTH]
binding relevant in = [macros_noargs.m --> id _MIPIC_COMMAND_LENGTH]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_COMMAND_LENGTH]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIC_CTRL]
binding relevant in = [macros_noargs.m --> id _MIPIC_CTRL]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_CTRL]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIC_DATA_ADDRESS]
binding relevant in = [macros_noargs.m --> id _MIPIC_DATA_ADDRESS]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_DATA_ADDRESS]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIC_DATA_LENGTH]
binding relevant in = [macros_noargs.m --> id _MIPIC_DATA_LENGTH]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_DATA_LENGTH]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIC_DBI_BW_CTRL]
binding relevant in = [macros_noargs.m --> id _MIPIC_DBI_BW_CTRL]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_DBI_BW_CTRL]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIC_DBI_FIFO_THROTTLE]
binding relevant in = [macros_noargs.m --> id _MIPIC_DBI_FIFO_THROTTLE]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_DBI_FIFO_THROTTLE]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIC_DEVICE_READY]
binding relevant in = [macros_noargs.m --> id _MIPIC_DEVICE_READY]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_DEVICE_READY]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIC_DEVICE_RESET_TIMER]
binding relevant in = [macros_noargs.m --> id _MIPIC_DEVICE_RESET_TIMER]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_DEVICE_RESET_TIMER]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIC_DPHY_PARAM]
binding relevant in = [macros_noargs.m --> id _MIPIC_DPHY_PARAM]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_DPHY_PARAM]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIC_DPI_CONTROL]
binding relevant in = [macros_noargs.m --> id _MIPIC_DPI_CONTROL]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_DPI_CONTROL]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIC_DPI_DATA]
binding relevant in = [macros_noargs.m --> id _MIPIC_DPI_DATA]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_DPI_DATA]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIC_DPI_RESOLUTION]
binding relevant in = [macros_noargs.m --> id _MIPIC_DPI_RESOLUTION]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_DPI_RESOLUTION]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIC_DSI_FUNC_PRG]
binding relevant in = [macros_noargs.m --> id _MIPIC_DSI_FUNC_PRG]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_DSI_FUNC_PRG]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIC_EOT_DISABLE]
binding relevant in = [macros_noargs.m --> id _MIPIC_EOT_DISABLE]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_EOT_DISABLE]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIC_GEN_FIFO_STAT]
binding relevant in = [macros_noargs.m --> id _MIPIC_GEN_FIFO_STAT]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_GEN_FIFO_STAT]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIC_HACTIVE_AREA_COUNT]
binding relevant in = [macros_noargs.m --> id _MIPIC_HACTIVE_AREA_COUNT]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_HACTIVE_AREA_COUNT]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIC_HBP_COUNT]
binding relevant in = [macros_noargs.m --> id _MIPIC_HBP_COUNT]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_HBP_COUNT]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIC_HFP_COUNT]
binding relevant in = [macros_noargs.m --> id _MIPIC_HFP_COUNT]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_HFP_COUNT]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIC_HIGH_LOW_SWITCH_COUNT]
binding relevant in = [macros_noargs.m --> id _MIPIC_HIGH_LOW_SWITCH_COUNT]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_HIGH_LOW_SWITCH_COUNT]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIC_HSYNC_PADDING_COUNT]
binding relevant in = [macros_noargs.m --> id _MIPIC_HSYNC_PADDING_COUNT]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_HSYNC_PADDING_COUNT]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIC_HS_GEN_CTRL]
binding relevant in = [macros_noargs.m --> id _MIPIC_HS_GEN_CTRL]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_HS_GEN_CTRL]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIC_HS_GEN_DATA]
binding relevant in = [macros_noargs.m --> id _MIPIC_HS_GEN_DATA]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_HS_GEN_DATA]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIC_HS_LS_DBI_ENABLE]
binding relevant in = [macros_noargs.m --> id _MIPIC_HS_LS_DBI_ENABLE]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_HS_LP_DBI_ENABLE]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIC_HS_TX_TIMEOUT]
binding relevant in = [macros_noargs.m --> id _MIPIC_HS_TX_TIMEOUT]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_HS_TX_TIMEOUT]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIC_INIT_COUNT]
binding relevant in = [macros_noargs.m --> id _MIPIC_INIT_COUNT]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_INIT_COUNT]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIC_INTR_EN]
binding relevant in = [macros_noargs.m --> id _MIPIC_INTR_EN]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_INTR_EN]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIC_INTR_EN_REG_1]
binding relevant in = [macros_noargs.m --> id _MIPIC_INTR_EN_REG_1]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_INTR_EN_REG_1]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIC_INTR_STAT]
binding relevant in = [macros_noargs.m --> id _MIPIC_INTR_STAT]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_INTR_STAT]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIC_INTR_STAT_REG_1]
binding relevant in = [macros_noargs.m --> id _MIPIC_INTR_STAT_REG_1]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_INTR_STAT_REG_1]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIC_LP_BYTECLK]
binding relevant in = [macros_noargs.m --> id _MIPIC_LP_BYTECLK]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_LP_BYTECLK]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIC_LP_GEN_CTRL]
binding relevant in = [macros_noargs.m --> id _MIPIC_LP_GEN_CTRL]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_LP_GEN_CTRL]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIC_LP_GEN_DATA]
binding relevant in = [macros_noargs.m --> id _MIPIC_LP_GEN_DATA]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_LP_GEN_DATA]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIC_LP_RX_TIMEOUT]
binding relevant in = [macros_noargs.m --> id _MIPIC_LP_RX_TIMEOUT]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_LP_RX_TIMEOUT]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIC_MAX_RETURN_PKT_SIZE]
binding relevant in = [macros_noargs.m --> id _MIPIC_MAX_RETURN_PKT_SIZE]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_MAX_RETURN_PKT_SIZE]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIC_READ_DATA_RETURN0]
binding relevant in = [macros_noargs.m --> id _MIPIC_READ_DATA_RETURN0]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_READ_DATA_RETURN]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIC_READ_DATA_VALID]
binding relevant in = [macros_noargs.m --> id _MIPIC_READ_DATA_VALID]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_READ_DATA_VALID]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIC_STOP_STATE_STALL]
binding relevant in = [macros_noargs.m --> id _MIPIC_STOP_STATE_STALL]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_STOP_STATE_STALL]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIC_TLPX_TIME_COUNT]
binding relevant in = [macros_noargs.m --> id _MIPIC_TLPX_TIME_COUNT]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_TLPX_TIME_COUNT]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIC_TURN_AROUND_TIMEOUT]
binding relevant in = [macros_noargs.m --> id _MIPIC_TURN_AROUND_TIMEOUT]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_TURN_AROUND_TIMEOUT]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIC_VBP_COUNT]
binding relevant in = [macros_noargs.m --> id _MIPIC_VBP_COUNT]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_VBP_COUNT]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIC_VFP_COUNT]
binding relevant in = [macros_noargs.m --> id _MIPIC_VFP_COUNT]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_VFP_COUNT]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIC_VIDEO_MODE_FORMAT]
binding relevant in = [macros_noargs.m --> id _MIPIC_VIDEO_MODE_FORMAT]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_VIDEO_MODE_FORMAT]
dependencies for rule nested_macros satisfied:
binding in = [macros_noargs.m --> id _MIPIC_VSYNC_PADDING_COUNT]
binding relevant in = [macros_noargs.m --> id _MIPIC_VSYNC_PADDING_COUNT]
     transformation info is empty
     binding out = [nested_macros.nm --> id MIPI_VSYNC_PADDING_COUNT]
-----------------------------------------------------------------------
rule starting on line 14 = 
-----------------------------------------------------------------------
dependencies for rule rule starting on line 14 satisfied:
binding in = []
binding relevant in = []
     (ONCE) USING optional_qualifier builtin isomorphism
dependencies for rule rule starting on line 14 satisfied:
binding in = [nested_macros.nm --> id MIPI_CLK_LANE_SWITCH_TIME_CNT]
binding relevant in = [nested_macros.nm --> id MIPI_CLK_LANE_SWITCH_TIME_CNT]
dependencies for rule rule starting on line 14 satisfied:
binding in = [nested_macros.nm --> id MIPI_CLK_LANE_TIMING]
binding relevant in = [nested_macros.nm --> id MIPI_CLK_LANE_TIMING]
dependencies for rule rule starting on line 14 satisfied:
binding in = [nested_macros.nm --> id MIPI_COMMAND_ADDRESS]
binding relevant in = [nested_macros.nm --> id MIPI_COMMAND_ADDRESS]
dependencies for rule rule starting on line 14 satisfied:
binding in = [nested_macros.nm --> id MIPI_COMMAND_LENGTH]
binding relevant in = [nested_macros.nm --> id MIPI_COMMAND_LENGTH]
dependencies for rule rule starting on line 14 satisfied:
binding in = [nested_macros.nm --> id MIPI_CTRL]
binding relevant in = [nested_macros.nm --> id MIPI_CTRL]
     (ONCE) USING optional_storage builtin isomorphism
     transformation info returned:
          transform state: 50
warning: rule starting on line 14, node 50: tmp = ... ;[1,2,8,9,20] in bxt_get_dsi_transcoder_state may be inconsistently modified
               with rule_elem: nm(
                                    <<< dev_priv, 
                                  el)
               with binding: [rule starting on line 14.dev_priv --> id dev_priv;
                             nested_macros.nm --> id MIPI_CTRL]
     binding out = []
     transform one node: 50
dependencies for rule rule starting on line 14 satisfied:
binding in = [nested_macros.nm --> id MIPI_DATA_ADDRESS]
binding relevant in = [nested_macros.nm --> id MIPI_DATA_ADDRESS]
dependencies for rule rule starting on line 14 satisfied:
binding in = [nested_macros.nm --> id MIPI_DATA_LENGTH]
binding relevant in = [nested_macros.nm --> id MIPI_DATA_LENGTH]
dependencies for rule rule starting on line 14 satisfied:
binding in = [nested_macros.nm --> id MIPI_DBI_BW_CTRL]
binding relevant in = [nested_macros.nm --> id MIPI_DBI_BW_CTRL]
dependencies for rule rule starting on line 14 satisfied:
binding in = [nested_macros.nm --> id MIPI_DBI_FIFO_THROTTLE]
binding relevant in = [nested_macros.nm --> id MIPI_DBI_FIFO_THROTTLE]
dependencies for rule rule starting on line 14 satisfied:
binding in = [nested_macros.nm --> id MIPI_DEVICE_READY]
binding relevant in = [nested_macros.nm --> id MIPI_DEVICE_READY]
dependencies for rule rule starting on line 14 satisfied:
binding in = [nested_macros.nm --> id MIPI_DEVICE_RESET_TIMER]
binding relevant in = [nested_macros.nm --> id MIPI_DEVICE_RESET_TIMER]
dependencies for rule rule starting on line 14 satisfied:
binding in = [nested_macros.nm --> id MIPI_DPHY_PARAM]
binding relevant in = [nested_macros.nm --> id MIPI_DPHY_PARAM]
dependencies for rule rule starting on line 14 satisfied:
binding in = [nested_macros.nm --> id MIPI_DPI_CONTROL]
binding relevant in = [nested_macros.nm --> id MIPI_DPI_CONTROL]
dependencies for rule rule starting on line 14 satisfied:
binding in = [nested_macros.nm --> id MIPI_DPI_DATA]
binding relevant in = [nested_macros.nm --> id MIPI_DPI_DATA]
dependencies for rule rule starting on line 14 satisfied:
binding in = [nested_macros.nm --> id MIPI_DPI_RESOLUTION]
binding relevant in = [nested_macros.nm --> id MIPI_DPI_RESOLUTION]
dependencies for rule rule starting on line 14 satisfied:
binding in = [nested_macros.nm --> id MIPI_DSI_FUNC_PRG]
binding relevant in = [nested_macros.nm --> id MIPI_DSI_FUNC_PRG]
dependencies for rule rule starting on line 14 satisfied:
binding in = [nested_macros.nm --> id MIPI_EOT_DISABLE]
binding relevant in = [nested_macros.nm --> id MIPI_EOT_DISABLE]
dependencies for rule rule starting on line 14 satisfied:
binding in = [nested_macros.nm --> id MIPI_GEN_FIFO_STAT]
binding relevant in = [nested_macros.nm --> id MIPI_GEN_FIFO_STAT]
dependencies for rule rule starting on line 14 satisfied:
binding in = [nested_macros.nm --> id MIPI_HACTIVE_AREA_COUNT]
binding relevant in = [nested_macros.nm --> id MIPI_HACTIVE_AREA_COUNT]
dependencies for rule rule starting on line 14 satisfied:
binding in = [nested_macros.nm --> id MIPI_HBP_COUNT]
binding relevant in = [nested_macros.nm --> id MIPI_HBP_COUNT]
dependencies for rule rule starting on line 14 satisfied:
binding in = [nested_macros.nm --> id MIPI_HFP_COUNT]
binding relevant in = [nested_macros.nm --> id MIPI_HFP_COUNT]
dependencies for rule rule starting on line 14 satisfied:
binding in = [nested_macros.nm --> id MIPI_HIGH_LOW_SWITCH_COUNT]
binding relevant in = [nested_macros.nm --> id MIPI_HIGH_LOW_SWITCH_COUNT]
dependencies for rule rule starting on line 14 satisfied:
binding in = [nested_macros.nm --> id MIPI_HSYNC_PADDING_COUNT]
binding relevant in = [nested_macros.nm --> id MIPI_HSYNC_PADDING_COUNT]
dependencies for rule rule starting on line 14 satisfied:
binding in = [nested_macros.nm --> id MIPI_HS_GEN_CTRL]
binding relevant in = [nested_macros.nm --> id MIPI_HS_GEN_CTRL]
dependencies for rule rule starting on line 14 satisfied:
binding in = [nested_macros.nm --> id MIPI_HS_GEN_DATA]
binding relevant in = [nested_macros.nm --> id MIPI_HS_GEN_DATA]
dependencies for rule rule starting on line 14 satisfied:
binding in = [nested_macros.nm --> id MIPI_HS_LP_DBI_ENABLE]
binding relevant in = [nested_macros.nm --> id MIPI_HS_LP_DBI_ENABLE]
dependencies for rule rule starting on line 14 satisfied:
binding in = [nested_macros.nm --> id MIPI_HS_TX_TIMEOUT]
binding relevant in = [nested_macros.nm --> id MIPI_HS_TX_TIMEOUT]
dependencies for rule rule starting on line 14 satisfied:
binding in = [nested_macros.nm --> id MIPI_INIT_COUNT]
binding relevant in = [nested_macros.nm --> id MIPI_INIT_COUNT]
dependencies for rule rule starting on line 14 satisfied:
binding in = [nested_macros.nm --> id MIPI_INTR_EN]
binding relevant in = [nested_macros.nm --> id MIPI_INTR_EN]
dependencies for rule rule starting on line 14 satisfied:
binding in = [nested_macros.nm --> id MIPI_INTR_EN_REG_1]
binding relevant in = [nested_macros.nm --> id MIPI_INTR_EN_REG_1]
dependencies for rule rule starting on line 14 satisfied:
binding in = [nested_macros.nm --> id MIPI_INTR_STAT]
binding relevant in = [nested_macros.nm --> id MIPI_INTR_STAT]
dependencies for rule rule starting on line 14 satisfied:
binding in = [nested_macros.nm --> id MIPI_INTR_STAT_REG_1]
binding relevant in = [nested_macros.nm --> id MIPI_INTR_STAT_REG_1]
dependencies for rule rule starting on line 14 satisfied:
binding in = [nested_macros.nm --> id MIPI_LP_BYTECLK]
binding relevant in = [nested_macros.nm --> id MIPI_LP_BYTECLK]
dependencies for rule rule starting on line 14 satisfied:
binding in = [nested_macros.nm --> id MIPI_LP_GEN_CTRL]
binding relevant in = [nested_macros.nm --> id MIPI_LP_GEN_CTRL]
dependencies for rule rule starting on line 14 satisfied:
binding in = [nested_macros.nm --> id MIPI_LP_GEN_DATA]
binding relevant in = [nested_macros.nm --> id MIPI_LP_GEN_DATA]
dependencies for rule rule starting on line 14 satisfied:
binding in = [nested_macros.nm --> id MIPI_LP_RX_TIMEOUT]
binding relevant in = [nested_macros.nm --> id MIPI_LP_RX_TIMEOUT]
dependencies for rule rule starting on line 14 satisfied:
binding in = [nested_macros.nm --> id MIPI_MAX_RETURN_PKT_SIZE]
binding relevant in = [nested_macros.nm --> id MIPI_MAX_RETURN_PKT_SIZE]
dependencies for rule rule starting on line 14 satisfied:
binding in = [nested_macros.nm --> id MIPI_READ_DATA_RETURN]
binding relevant in = [nested_macros.nm --> id MIPI_READ_DATA_RETURN]
dependencies for rule rule starting on line 14 satisfied:
binding in = [nested_macros.nm --> id MIPI_READ_DATA_VALID]
binding relevant in = [nested_macros.nm --> id MIPI_READ_DATA_VALID]
dependencies for rule rule starting on line 14 satisfied:
binding in = [nested_macros.nm --> id MIPI_STOP_STATE_STALL]
binding relevant in = [nested_macros.nm --> id MIPI_STOP_STATE_STALL]
dependencies for rule rule starting on line 14 satisfied:
binding in = [nested_macros.nm --> id MIPI_TLPX_TIME_COUNT]
binding relevant in = [nested_macros.nm --> id MIPI_TLPX_TIME_COUNT]
dependencies for rule rule starting on line 14 satisfied:
binding in = [nested_macros.nm --> id MIPI_TURN_AROUND_TIMEOUT]
binding relevant in = [nested_macros.nm --> id MIPI_TURN_AROUND_TIMEOUT]
dependencies for rule rule starting on line 14 satisfied:
binding in = [nested_macros.nm --> id MIPI_VBP_COUNT]
binding relevant in = [nested_macros.nm --> id MIPI_VBP_COUNT]
dependencies for rule rule starting on line 14 satisfied:
binding in = [nested_macros.nm --> id MIPI_VFP_COUNT]
binding relevant in = [nested_macros.nm --> id MIPI_VFP_COUNT]
dependencies for rule rule starting on line 14 satisfied:
binding in = [nested_macros.nm --> id MIPI_VIDEO_MODE_FORMAT]
binding relevant in = [nested_macros.nm --> id MIPI_VIDEO_MODE_FORMAT]
dependencies for rule rule starting on line 14 satisfied:
binding in = [nested_macros.nm --> id MIPI_VSYNC_PADDING_COUNT]
binding relevant in = [nested_macros.nm --> id MIPI_VSYNC_PADDING_COUNT]
-----------------------------------------------------------------------
rule starting on line 30 = 
-----------------------------------------------------------------------
dependencies for rule rule starting on line 30 satisfied:
binding in = []
binding relevant in = []
dependencies for rule rule starting on line 30 satisfied:
binding in = [nested_macros.nm --> id MIPI_CLK_LANE_SWITCH_TIME_CNT]
binding relevant in = [nested_macros.nm --> id MIPI_CLK_LANE_SWITCH_TIME_CNT]
dependencies for rule rule starting on line 30 satisfied:
binding in = [nested_macros.nm --> id MIPI_CLK_LANE_TIMING]
binding relevant in = [nested_macros.nm --> id MIPI_CLK_LANE_TIMING]
dependencies for rule rule starting on line 30 satisfied:
binding in = [nested_macros.nm --> id MIPI_COMMAND_ADDRESS]
binding relevant in = [nested_macros.nm --> id MIPI_COMMAND_ADDRESS]
dependencies for rule rule starting on line 30 satisfied:
binding in = [nested_macros.nm --> id MIPI_COMMAND_LENGTH]
binding relevant in = [nested_macros.nm --> id MIPI_COMMAND_LENGTH]
dependencies for rule rule starting on line 30 satisfied:
binding in = [nested_macros.nm --> id MIPI_CTRL]
binding relevant in = [nested_macros.nm --> id MIPI_CTRL]
dependencies for rule rule starting on line 30 satisfied:
binding in = [nested_macros.nm --> id MIPI_DATA_ADDRESS]
binding relevant in = [nested_macros.nm --> id MIPI_DATA_ADDRESS]
dependencies for rule rule starting on line 30 satisfied:
binding in = [nested_macros.nm --> id MIPI_DATA_LENGTH]
binding relevant in = [nested_macros.nm --> id MIPI_DATA_LENGTH]
dependencies for rule rule starting on line 30 satisfied:
binding in = [nested_macros.nm --> id MIPI_DBI_BW_CTRL]
binding relevant in = [nested_macros.nm --> id MIPI_DBI_BW_CTRL]
dependencies for rule rule starting on line 30 satisfied:
binding in = [nested_macros.nm --> id MIPI_DBI_FIFO_THROTTLE]
binding relevant in = [nested_macros.nm --> id MIPI_DBI_FIFO_THROTTLE]
dependencies for rule rule starting on line 30 satisfied:
binding in = [nested_macros.nm --> id MIPI_DEVICE_READY]
binding relevant in = [nested_macros.nm --> id MIPI_DEVICE_READY]
dependencies for rule rule starting on line 30 satisfied:
binding in = [nested_macros.nm --> id MIPI_DEVICE_RESET_TIMER]
binding relevant in = [nested_macros.nm --> id MIPI_DEVICE_RESET_TIMER]
dependencies for rule rule starting on line 30 satisfied:
binding in = [nested_macros.nm --> id MIPI_DPHY_PARAM]
binding relevant in = [nested_macros.nm --> id MIPI_DPHY_PARAM]
dependencies for rule rule starting on line 30 satisfied:
binding in = [nested_macros.nm --> id MIPI_DPI_CONTROL]
binding relevant in = [nested_macros.nm --> id MIPI_DPI_CONTROL]
dependencies for rule rule starting on line 30 satisfied:
binding in = [nested_macros.nm --> id MIPI_DPI_DATA]
binding relevant in = [nested_macros.nm --> id MIPI_DPI_DATA]
dependencies for rule rule starting on line 30 satisfied:
binding in = [nested_macros.nm --> id MIPI_DPI_RESOLUTION]
binding relevant in = [nested_macros.nm --> id MIPI_DPI_RESOLUTION]
dependencies for rule rule starting on line 30 satisfied:
binding in = [nested_macros.nm --> id MIPI_DSI_FUNC_PRG]
binding relevant in = [nested_macros.nm --> id MIPI_DSI_FUNC_PRG]
dependencies for rule rule starting on line 30 satisfied:
binding in = [nested_macros.nm --> id MIPI_EOT_DISABLE]
binding relevant in = [nested_macros.nm --> id MIPI_EOT_DISABLE]
dependencies for rule rule starting on line 30 satisfied:
binding in = [nested_macros.nm --> id MIPI_GEN_FIFO_STAT]
binding relevant in = [nested_macros.nm --> id MIPI_GEN_FIFO_STAT]
dependencies for rule rule starting on line 30 satisfied:
binding in = [nested_macros.nm --> id MIPI_HACTIVE_AREA_COUNT]
binding relevant in = [nested_macros.nm --> id MIPI_HACTIVE_AREA_COUNT]
dependencies for rule rule starting on line 30 satisfied:
binding in = [nested_macros.nm --> id MIPI_HBP_COUNT]
binding relevant in = [nested_macros.nm --> id MIPI_HBP_COUNT]
dependencies for rule rule starting on line 30 satisfied:
binding in = [nested_macros.nm --> id MIPI_HFP_COUNT]
binding relevant in = [nested_macros.nm --> id MIPI_HFP_COUNT]
dependencies for rule rule starting on line 30 satisfied:
binding in = [nested_macros.nm --> id MIPI_HIGH_LOW_SWITCH_COUNT]
binding relevant in = [nested_macros.nm --> id MIPI_HIGH_LOW_SWITCH_COUNT]
dependencies for rule rule starting on line 30 satisfied:
binding in = [nested_macros.nm --> id MIPI_HSYNC_PADDING_COUNT]
binding relevant in = [nested_macros.nm --> id MIPI_HSYNC_PADDING_COUNT]
dependencies for rule rule starting on line 30 satisfied:
binding in = [nested_macros.nm --> id MIPI_HS_GEN_CTRL]
binding relevant in = [nested_macros.nm --> id MIPI_HS_GEN_CTRL]
dependencies for rule rule starting on line 30 satisfied:
binding in = [nested_macros.nm --> id MIPI_HS_GEN_DATA]
binding relevant in = [nested_macros.nm --> id MIPI_HS_GEN_DATA]
dependencies for rule rule starting on line 30 satisfied:
binding in = [nested_macros.nm --> id MIPI_HS_LP_DBI_ENABLE]
binding relevant in = [nested_macros.nm --> id MIPI_HS_LP_DBI_ENABLE]
dependencies for rule rule starting on line 30 satisfied:
binding in = [nested_macros.nm --> id MIPI_HS_TX_TIMEOUT]
binding relevant in = [nested_macros.nm --> id MIPI_HS_TX_TIMEOUT]
dependencies for rule rule starting on line 30 satisfied:
binding in = [nested_macros.nm --> id MIPI_INIT_COUNT]
binding relevant in = [nested_macros.nm --> id MIPI_INIT_COUNT]
dependencies for rule rule starting on line 30 satisfied:
binding in = [nested_macros.nm --> id MIPI_INTR_EN]
binding relevant in = [nested_macros.nm --> id MIPI_INTR_EN]
dependencies for rule rule starting on line 30 satisfied:
binding in = [nested_macros.nm --> id MIPI_INTR_EN_REG_1]
binding relevant in = [nested_macros.nm --> id MIPI_INTR_EN_REG_1]
dependencies for rule rule starting on line 30 satisfied:
binding in = [nested_macros.nm --> id MIPI_INTR_STAT]
binding relevant in = [nested_macros.nm --> id MIPI_INTR_STAT]
dependencies for rule rule starting on line 30 satisfied:
binding in = [nested_macros.nm --> id MIPI_INTR_STAT_REG_1]
binding relevant in = [nested_macros.nm --> id MIPI_INTR_STAT_REG_1]
dependencies for rule rule starting on line 30 satisfied:
binding in = [nested_macros.nm --> id MIPI_LP_BYTECLK]
binding relevant in = [nested_macros.nm --> id MIPI_LP_BYTECLK]
dependencies for rule rule starting on line 30 satisfied:
binding in = [nested_macros.nm --> id MIPI_LP_GEN_CTRL]
binding relevant in = [nested_macros.nm --> id MIPI_LP_GEN_CTRL]
dependencies for rule rule starting on line 30 satisfied:
binding in = [nested_macros.nm --> id MIPI_LP_GEN_DATA]
binding relevant in = [nested_macros.nm --> id MIPI_LP_GEN_DATA]
dependencies for rule rule starting on line 30 satisfied:
binding in = [nested_macros.nm --> id MIPI_LP_RX_TIMEOUT]
binding relevant in = [nested_macros.nm --> id MIPI_LP_RX_TIMEOUT]
dependencies for rule rule starting on line 30 satisfied:
binding in = [nested_macros.nm --> id MIPI_MAX_RETURN_PKT_SIZE]
binding relevant in = [nested_macros.nm --> id MIPI_MAX_RETURN_PKT_SIZE]
dependencies for rule rule starting on line 30 satisfied:
binding in = [nested_macros.nm --> id MIPI_READ_DATA_RETURN]
binding relevant in = [nested_macros.nm --> id MIPI_READ_DATA_RETURN]
dependencies for rule rule starting on line 30 satisfied:
binding in = [nested_macros.nm --> id MIPI_READ_DATA_VALID]
binding relevant in = [nested_macros.nm --> id MIPI_READ_DATA_VALID]
dependencies for rule rule starting on line 30 satisfied:
binding in = [nested_macros.nm --> id MIPI_STOP_STATE_STALL]
binding relevant in = [nested_macros.nm --> id MIPI_STOP_STATE_STALL]
dependencies for rule rule starting on line 30 satisfied:
binding in = [nested_macros.nm --> id MIPI_TLPX_TIME_COUNT]
binding relevant in = [nested_macros.nm --> id MIPI_TLPX_TIME_COUNT]
dependencies for rule rule starting on line 30 satisfied:
binding in = [nested_macros.nm --> id MIPI_TURN_AROUND_TIMEOUT]
binding relevant in = [nested_macros.nm --> id MIPI_TURN_AROUND_TIMEOUT]
dependencies for rule rule starting on line 30 satisfied:
binding in = [nested_macros.nm --> id MIPI_VBP_COUNT]
binding relevant in = [nested_macros.nm --> id MIPI_VBP_COUNT]
dependencies for rule rule starting on line 30 satisfied:
binding in = [nested_macros.nm --> id MIPI_VFP_COUNT]
binding relevant in = [nested_macros.nm --> id MIPI_VFP_COUNT]
dependencies for rule rule starting on line 30 satisfied:
binding in = [nested_macros.nm --> id MIPI_VIDEO_MODE_FORMAT]
binding relevant in = [nested_macros.nm --> id MIPI_VIDEO_MODE_FORMAT]
dependencies for rule rule starting on line 30 satisfied:
binding in = [nested_macros.nm --> id MIPI_VSYNC_PADDING_COUNT]
binding relevant in = [nested_macros.nm --> id MIPI_VSYNC_PADDING_COUNT]
-----------------------------------------------------------------------
Finished
-----------------------------------------------------------------------
ERROR-RECOV: found sync end of #define, line 162
parsing pass2: try again
ERROR-RECOV: found sync end of #define, line 162
parse error 
 = File "./intel_display_power.h", line 162, column 51, charpos = 4051
  around = '',
  whole content = 		for_each_if(test_bit((__domain), (__mask)->bits))
badcount: 4
bad: };
bad: 
bad: #define for_each_power_domain(__domain, __mask)				\
bad: 	for ((__domain) = 0; (__domain) < POWER_DOMAIN_NUM; (__domain)++)	\
BAD:!!!!! 		for_each_if(test_bit((__domain), (__mask)->bits))
ERROR-RECOV: found sync end of #define, line 282
parsing pass2: try again
ERROR-RECOV: found sync end of #define, line 282
parse error 
 = File "./intel_display_power.h", line 282, column 70, charpos = 8858
  around = '',
  whole content = 	     intel_display_power_put_async((i915), (domain), (wf)), (wf) = 0)
badcount: 4
bad: 			     u8 req_slices);
bad: 
bad: #define with_intel_display_power(i915, domain, wf) \
bad: 	for ((wf) = intel_display_power_get((i915), (domain)); (wf); \
BAD:!!!!! 	     intel_display_power_put_async((i915), (domain), (wf)), (wf) = 0)
ERROR-RECOV: found sync end of #define, line 286
parsing pass2: try again
ERROR-RECOV: found sync end of #define, line 286
parse error 
 = File "./intel_display_power.h", line 286, column 70, charpos = 9069
  around = '',
  whole content = 	     intel_display_power_put_async((i915), (domain), (wf)), (wf) = 0)
badcount: 4
bad: 	     intel_display_power_put_async((i915), (domain), (wf)), (wf) = 0)
bad: 
bad: #define with_intel_display_power_if_enabled(i915, domain, wf) \
bad: 	for ((wf) = intel_display_power_get_if_enabled((i915), (domain)); (wf); \
BAD:!!!!! 	     intel_display_power_put_async((i915), (domain), (wf)), (wf) = 0)
ERROR-RECOV: found sync end of #define, line 24
parsing pass2: try again
ERROR-RECOV: found sync end of #define, line 24
parse error 
 = File "./intel_pps.h", line 24, column 75, charpos = 574
  around = '',
  whole content = 	for ((wf) = intel_pps_lock(dp); (wf); (wf) = intel_pps_unlock((dp), (wf)))
badcount: 3
bad: intel_wakeref_t intel_pps_unlock(struct intel_dp *intel_dp, intel_wakeref_t wakeref);
bad: 
bad: #define with_intel_pps_lock(dp, wf)						\
BAD:!!!!! 	for ((wf) = intel_pps_lock(dp); (wf); (wf) = intel_pps_unlock((dp), (wf)))
ERROR-RECOV: found sync '}' at line 3711
parsing pass2: try again
ERROR-RECOV: found sync '}' at line 3711
parsing pass3: try again
ERROR-RECOV: found sync '}' at line 3711
parse error 
 = File "intel_display.c", line 3708, column 2, charpos = 111316
  around = 'tmp',
  whole content = 		tmp = intel_de_read(dev_priv, TRANS_DDI_FUNC_CTL(cpu_transcoder));
badcount: 15
bad: }
bad: 
bad: static bool transcoder_ddi_func_is_enabled(struct drm_i915_private *dev_priv,
bad: 					   enum transcoder cpu_transcoder)
bad: {
bad: 	enum intel_display_power_domain power_domain;
bad: 	intel_wakeref_t wakeref;
bad: 	u32 tmp = 0;
bad: 
bad: 	power_domain = POWER_DOMAIN_TRANSCODER(cpu_transcoder);
bad: 
bad: 	with_intel_display_power_if_enabled(dev_priv, power_domain, wakeref)
BAD:!!!!! 		tmp = intel_de_read(dev_priv, TRANS_DDI_FUNC_CTL(cpu_transcoder));
bad: 
bad: 	return tmp & TRANS_DDI_FUNC_ENABLE;
bad: }
ERROR-RECOV: found sync '}' at line 3758
parsing pass2: try again
ERROR-RECOV: found sync '}' at line 3758
parsing pass3: try again
ERROR-RECOV: found sync '}' at line 3758
parse error 
 = File "intel_display.c", line 3728, column 71, charpos = 111947
  around = '{',
  whole content = 		with_intel_display_power_if_enabled(dev_priv, power_domain, wakeref) {
badcount: 47
bad: }
bad: 
bad: static void enabled_bigjoiner_pipes(struct drm_i915_private *dev_priv,
bad: 				    u8 *master_pipes, u8 *slave_pipes)
bad: {
bad: 	struct intel_crtc *crtc;
bad: 
bad: 	*master_pipes = 0;
bad: 	*slave_pipes = 0;
bad: 
bad: 	for_each_intel_crtc_in_pipe_mask(&dev_priv->drm, crtc,
bad: 					 bigjoiner_pipes(dev_priv)) {
bad: 		enum intel_display_power_domain power_domain;
bad: 		enum pipe pipe = crtc->pipe;
bad: 		intel_wakeref_t wakeref;
bad: 
bad: 		power_domain = intel_dsc_power_domain(crtc, (enum transcoder) pipe);
BAD:!!!!! 		with_intel_display_power_if_enabled(dev_priv, power_domain, wakeref) {
bad: 			u32 tmp = intel_de_read(dev_priv, ICL_PIPE_DSS_CTL1(pipe));
bad: 
bad: 			if (!(tmp & BIG_JOINER_ENABLE))
bad: 				continue;
bad: 
bad: 			if (tmp & MASTER_BIG_JOINER_ENABLE)
bad: 				*master_pipes |= BIT(pipe);
bad: 			else
bad: 				*slave_pipes |= BIT(pipe);
bad: 		}
bad: 
bad: 		if (DISPLAY_VER(dev_priv) < 13)
bad: 			continue;
bad: 
bad: 		power_domain = POWER_DOMAIN_PIPE(pipe);
bad: 		with_intel_display_power_if_enabled(dev_priv, power_domain, wakeref) {
bad: 			u32 tmp = intel_de_read(dev_priv, ICL_PIPE_DSS_CTL1(pipe));
bad: 
bad: 			if (tmp & UNCOMPRESSED_JOINER_MASTER)
bad: 				*master_pipes |= BIT(pipe);
bad: 			if (tmp & UNCOMPRESSED_JOINER_SLAVE)
bad: 				*slave_pipes |= BIT(pipe);
bad: 		}
bad: 	}
bad: 
bad: 	/* Bigjoiner pipes should always be consecutive master and slave */
bad: 	drm_WARN(&dev_priv->drm, *slave_pipes != *master_pipes << 1,
bad: 		 "Bigjoiner misconfigured (master pipes 0x%x, slave pipes 0x%x)\n",
bad: 		 *master_pipes, *slave_pipes);
bad: }
ERROR-RECOV: found sync '}' at line 3868
parsing pass2: try again
ERROR-RECOV: found sync '}' at line 3868
parsing pass3: try again
ERROR-RECOV: found sync '}' at line 3868
parse error 
 = File "intel_display.c", line 3823, column 3, charpos = 114767
  around = 'tmp',
  whole content = 			tmp = intel_de_read(dev_priv, TRANS_DDI_FUNC_CTL(cpu_transcoder));
badcount: 69
bad: }
bad: 
bad: static u8 hsw_enabled_transcoders(struct intel_crtc *crtc)
bad: {
bad: 	struct drm_device *dev = crtc->base.dev;
bad: 	struct drm_i915_private *dev_priv = to_i915(dev);
bad: 	u8 panel_transcoder_mask = hsw_panel_transcoders(dev_priv);
bad: 	enum transcoder cpu_transcoder;
bad: 	u8 master_pipes, slave_pipes;
bad: 	u8 enabled_transcoders = 0;
bad: 
bad: 	/*
bad: 	 * XXX: Do intel_display_power_get_if_enabled before reading this (for
bad: 	 * consistency and less surprising code; it's in always on power).
bad: 	 */
bad: 	for_each_cpu_transcoder_masked(dev_priv, cpu_transcoder,
bad: 				       panel_transcoder_mask) {
bad: 		enum intel_display_power_domain power_domain;
bad: 		intel_wakeref_t wakeref;
bad: 		enum pipe trans_pipe;
bad: 		u32 tmp = 0;
bad: 
bad: 		power_domain = POWER_DOMAIN_TRANSCODER(cpu_transcoder);
bad: 		with_intel_display_power_if_enabled(dev_priv, power_domain, wakeref)
BAD:!!!!! 			tmp = intel_de_read(dev_priv, TRANS_DDI_FUNC_CTL(cpu_transcoder));
bad: 
bad: 		if (!(tmp & TRANS_DDI_FUNC_ENABLE))
bad: 			continue;
bad: 
bad: 		switch (tmp & TRANS_DDI_EDP_INPUT_MASK) {
bad: 		default:
bad: 			drm_WARN(dev, 1,
bad: 				 "unknown pipe linked to transcoder %s\n",
bad: 				 transcoder_name(cpu_transcoder));
bad: 			fallthrough;
bad: 		case TRANS_DDI_EDP_INPUT_A_ONOFF:
bad: 		case TRANS_DDI_EDP_INPUT_A_ON:
bad: 			trans_pipe = PIPE_A;
bad: 			break;
bad: 		case TRANS_DDI_EDP_INPUT_B_ONOFF:
bad: 			trans_pipe = PIPE_B;
bad: 			break;
bad: 		case TRANS_DDI_EDP_INPUT_C_ONOFF:
bad: 			trans_pipe = PIPE_C;
bad: 			break;
bad: 		case TRANS_DDI_EDP_INPUT_D_ONOFF:
bad: 			trans_pipe = PIPE_D;
bad: 			break;
bad: 		}
bad: 
bad: 		if (trans_pipe == crtc->pipe)
bad: 			enabled_transcoders |= BIT(cpu_transcoder);
bad: 	}
bad: 
bad: 	/* single pipe or bigjoiner master */
bad: 	cpu_transcoder = (enum transcoder) crtc->pipe;
bad: 	if (transcoder_ddi_func_is_enabled(dev_priv, cpu_transcoder))
bad: 		enabled_transcoders |= BIT(cpu_transcoder);
bad: 
bad: 	/* bigjoiner slave -> consider the master pipe's transcoder as well */
bad: 	enabled_bigjoiner_pipes(dev_priv, &master_pipes, &slave_pipes);
bad: 	if (slave_pipes & BIT(crtc->pipe)) {
bad: 		cpu_transcoder = (enum transcoder)
bad: 			get_bigjoiner_master_pipe(crtc->pipe, master_pipes, slave_pipes);
bad: 		if (transcoder_ddi_func_is_enabled(dev_priv, cpu_transcoder))
bad: 			enabled_transcoders |= BIT(cpu_transcoder);
bad: 	}
bad: 
bad: 	return enabled_transcoders;
bad: }
ERROR-RECOV: found sync end of #define, line 162
parsing pass2: try again
ERROR-RECOV: found sync end of #define, line 162
parse error 
 = File "./intel_display_power.h", line 162, column 51, charpos = 4051
  around = '',
  whole content = 		for_each_if(test_bit((__domain), (__mask)->bits))
badcount: 4
bad: };
bad: 
bad: #define for_each_power_domain(__domain, __mask)				\
bad: 	for ((__domain) = 0; (__domain) < POWER_DOMAIN_NUM; (__domain)++)	\
BAD:!!!!! 		for_each_if(test_bit((__domain), (__mask)->bits))
ERROR-RECOV: found sync end of #define, line 282
parsing pass2: try again
ERROR-RECOV: found sync end of #define, line 282
parse error 
 = File "./intel_display_power.h", line 282, column 70, charpos = 8858
  around = '',
  whole content = 	     intel_display_power_put_async((i915), (domain), (wf)), (wf) = 0)
badcount: 4
bad: 			     u8 req_slices);
bad: 
bad: #define with_intel_display_power(i915, domain, wf) \
bad: 	for ((wf) = intel_display_power_get((i915), (domain)); (wf); \
BAD:!!!!! 	     intel_display_power_put_async((i915), (domain), (wf)), (wf) = 0)
ERROR-RECOV: found sync end of #define, line 286
parsing pass2: try again
ERROR-RECOV: found sync end of #define, line 286
parse error 
 = File "./intel_display_power.h", line 286, column 70, charpos = 9069
  around = '',
  whole content = 	     intel_display_power_put_async((i915), (domain), (wf)), (wf) = 0)
badcount: 4
bad: 	     intel_display_power_put_async((i915), (domain), (wf)), (wf) = 0)
bad: 
bad: #define with_intel_display_power_if_enabled(i915, domain, wf) \
bad: 	for ((wf) = intel_display_power_get_if_enabled((i915), (domain)); (wf); \
BAD:!!!!! 	     intel_display_power_put_async((i915), (domain), (wf)), (wf) = 0)
ERROR-RECOV: found sync end of #define, line 24
parsing pass2: try again
ERROR-RECOV: found sync end of #define, line 24
parse error 
 = File "./intel_pps.h", line 24, column 75, charpos = 574
  around = '',
  whole content = 	for ((wf) = intel_pps_lock(dp); (wf); (wf) = intel_pps_unlock((dp), (wf)))
badcount: 3
bad: intel_wakeref_t intel_pps_unlock(struct intel_dp *intel_dp, intel_wakeref_t wakeref);
bad: 
bad: #define with_intel_pps_lock(dp, wf)						\
BAD:!!!!! 	for ((wf) = intel_pps_lock(dp); (wf); (wf) = intel_pps_unlock((dp), (wf)))
ERROR-RECOV: found sync '}' at line 3711
parsing pass2: try again
ERROR-RECOV: found sync '}' at line 3711
parsing pass3: try again
ERROR-RECOV: found sync '}' at line 3711
parse error 
 = File "/tmp/cocci-output-254504-99ee4f-intel_display.c", line 3708, column 2, charpos = 111316
  around = 'tmp',
  whole content = 		tmp = intel_de_read(dev_priv, TRANS_DDI_FUNC_CTL(cpu_transcoder));
badcount: 15
bad: }
bad: 
bad: static bool transcoder_ddi_func_is_enabled(struct drm_i915_private *dev_priv,
bad: 					   enum transcoder cpu_transcoder)
bad: {
bad: 	enum intel_display_power_domain power_domain;
bad: 	intel_wakeref_t wakeref;
bad: 	u32 tmp = 0;
bad: 
bad: 	power_domain = POWER_DOMAIN_TRANSCODER(cpu_transcoder);
bad: 
bad: 	with_intel_display_power_if_enabled(dev_priv, power_domain, wakeref)
BAD:!!!!! 		tmp = intel_de_read(dev_priv, TRANS_DDI_FUNC_CTL(cpu_transcoder));
bad: 
bad: 	return tmp & TRANS_DDI_FUNC_ENABLE;
bad: }
ERROR-RECOV: found sync '}' at line 3758
parsing pass2: try again
ERROR-RECOV: found sync '}' at line 3758
parsing pass3: try again
ERROR-RECOV: found sync '}' at line 3758
parse error 
 = File "/tmp/cocci-output-254504-99ee4f-intel_display.c", line 3728, column 71, charpos = 111947
  around = '{',
  whole content = 		with_intel_display_power_if_enabled(dev_priv, power_domain, wakeref) {
badcount: 47
bad: }
bad: 
bad: static void enabled_bigjoiner_pipes(struct drm_i915_private *dev_priv,
bad: 				    u8 *master_pipes, u8 *slave_pipes)
bad: {
bad: 	struct intel_crtc *crtc;
bad: 
bad: 	*master_pipes = 0;
bad: 	*slave_pipes = 0;
bad: 
bad: 	for_each_intel_crtc_in_pipe_mask(&dev_priv->drm, crtc,
bad: 					 bigjoiner_pipes(dev_priv)) {
bad: 		enum intel_display_power_domain power_domain;
bad: 		enum pipe pipe = crtc->pipe;
bad: 		intel_wakeref_t wakeref;
bad: 
bad: 		power_domain = intel_dsc_power_domain(crtc, (enum transcoder) pipe);
BAD:!!!!! 		with_intel_display_power_if_enabled(dev_priv, power_domain, wakeref) {
bad: 			u32 tmp = intel_de_read(dev_priv, ICL_PIPE_DSS_CTL1(pipe));
bad: 
bad: 			if (!(tmp & BIG_JOINER_ENABLE))
bad: 				continue;
bad: 
bad: 			if (tmp & MASTER_BIG_JOINER_ENABLE)
bad: 				*master_pipes |= BIT(pipe);
bad: 			else
bad: 				*slave_pipes |= BIT(pipe);
bad: 		}
bad: 
bad: 		if (DISPLAY_VER(dev_priv) < 13)
bad: 			continue;
bad: 
bad: 		power_domain = POWER_DOMAIN_PIPE(pipe);
bad: 		with_intel_display_power_if_enabled(dev_priv, power_domain, wakeref) {
bad: 			u32 tmp = intel_de_read(dev_priv, ICL_PIPE_DSS_CTL1(pipe));
bad: 
bad: 			if (tmp & UNCOMPRESSED_JOINER_MASTER)
bad: 				*master_pipes |= BIT(pipe);
bad: 			if (tmp & UNCOMPRESSED_JOINER_SLAVE)
bad: 				*slave_pipes |= BIT(pipe);
bad: 		}
bad: 	}
bad: 
bad: 	/* Bigjoiner pipes should always be consecutive master and slave */
bad: 	drm_WARN(&dev_priv->drm, *slave_pipes != *master_pipes << 1,
bad: 		 "Bigjoiner misconfigured (master pipes 0x%x, slave pipes 0x%x)\n",
bad: 		 *master_pipes, *slave_pipes);
bad: }
ERROR-RECOV: found sync '}' at line 3868
parsing pass2: try again
ERROR-RECOV: found sync '}' at line 3868
parsing pass3: try again
ERROR-RECOV: found sync '}' at line 3868
parse error 
 = File "/tmp/cocci-output-254504-99ee4f-intel_display.c", line 3823, column 3, charpos = 114767
  around = 'tmp',
  whole content = 			tmp = intel_de_read(dev_priv, TRANS_DDI_FUNC_CTL(cpu_transcoder));
badcount: 69
bad: }
bad: 
bad: static u8 hsw_enabled_transcoders(struct intel_crtc *crtc)
bad: {
bad: 	struct drm_device *dev = crtc->base.dev;
bad: 	struct drm_i915_private *dev_priv = to_i915(dev);
bad: 	u8 panel_transcoder_mask = hsw_panel_transcoders(dev_priv);
bad: 	enum transcoder cpu_transcoder;
bad: 	u8 master_pipes, slave_pipes;
bad: 	u8 enabled_transcoders = 0;
bad: 
bad: 	/*
bad: 	 * XXX: Do intel_display_power_get_if_enabled before reading this (for
bad: 	 * consistency and less surprising code; it's in always on power).
bad: 	 */
bad: 	for_each_cpu_transcoder_masked(dev_priv, cpu_transcoder,
bad: 				       panel_transcoder_mask) {
bad: 		enum intel_display_power_domain power_domain;
bad: 		intel_wakeref_t wakeref;
bad: 		enum pipe trans_pipe;
bad: 		u32 tmp = 0;
bad: 
bad: 		power_domain = POWER_DOMAIN_TRANSCODER(cpu_transcoder);
bad: 		with_intel_display_power_if_enabled(dev_priv, power_domain, wakeref)
BAD:!!!!! 			tmp = intel_de_read(dev_priv, TRANS_DDI_FUNC_CTL(cpu_transcoder));
bad: 
bad: 		if (!(tmp & TRANS_DDI_FUNC_ENABLE))
bad: 			continue;
bad: 
bad: 		switch (tmp & TRANS_DDI_EDP_INPUT_MASK) {
bad: 		default:
bad: 			drm_WARN(dev, 1,
bad: 				 "unknown pipe linked to transcoder %s\n",
bad: 				 transcoder_name(cpu_transcoder));
bad: 			fallthrough;
bad: 		case TRANS_DDI_EDP_INPUT_A_ONOFF:
bad: 		case TRANS_DDI_EDP_INPUT_A_ON:
bad: 			trans_pipe = PIPE_A;
bad: 			break;
bad: 		case TRANS_DDI_EDP_INPUT_B_ONOFF:
bad: 			trans_pipe = PIPE_B;
bad: 			break;
bad: 		case TRANS_DDI_EDP_INPUT_C_ONOFF:
bad: 			trans_pipe = PIPE_C;
bad: 			break;
bad: 		case TRANS_DDI_EDP_INPUT_D_ONOFF:
bad: 			trans_pipe = PIPE_D;
bad: 			break;
bad: 		}
bad: 
bad: 		if (trans_pipe == crtc->pipe)
bad: 			enabled_transcoders |= BIT(cpu_transcoder);
bad: 	}
bad: 
bad: 	/* single pipe or bigjoiner master */
bad: 	cpu_transcoder = (enum transcoder) crtc->pipe;
bad: 	if (transcoder_ddi_func_is_enabled(dev_priv, cpu_transcoder))
bad: 		enabled_transcoders |= BIT(cpu_transcoder);
bad: 
bad: 	/* bigjoiner slave -> consider the master pipe's transcoder as well */
bad: 	enabled_bigjoiner_pipes(dev_priv, &master_pipes, &slave_pipes);
bad: 	if (slave_pipes & BIT(crtc->pipe)) {
bad: 		cpu_transcoder = (enum transcoder)
bad: 			get_bigjoiner_master_pipe(crtc->pipe, master_pipes, slave_pipes);
bad: 		if (transcoder_ddi_func_is_enabled(dev_priv, cpu_transcoder))
bad: 			enabled_transcoders |= BIT(cpu_transcoder);
bad: 	}
bad: 
bad: 	return enabled_transcoders;
bad: }
diff = 
--- intel_display.c
+++ /tmp/cocci-output-254504-99ee4f-intel_display.c
@@ -3973,7 +3973,8 @@ static bool bxt_get_dsi_transcoder_state
 		if (!(tmp & DPI_ENABLE))
 			continue;
 
-		tmp = intel_de_read(dev_priv, MIPI_CTRL(dev_priv, port));
+		tmp = intel_de_read(dev_priv,
+				    MIPI_CTRL(dev_priv, dev_priv, port));
 		if ((tmp & BXT_PIPE_SELECT_MASK) != BXT_PIPE_SELECT(crtc->pipe))
 			continue;
 
Check duplication for 70 files

Re: [cocci] Searching for special function implementations with SmPL

[Julia Lawall]

On Mon, 30 Jan 2023, Luca Coelho wrote:

> On Mon, 2023-01-30 at 09:37 +0100, Julia Lawall wrote:
> > > Sorry, false alarm.  I was running spatch by itself on an inner
> > > directory (.../i915/display), but when I used find, I was using
> > > .../i915, so there was one more match happening there.
> > >
> > > So, it seems that the latest head _does_ work fine! And I'm gettign
> > > all
> > > the matches and changes that I expect.  Thanks!
> >
> > Great news :)
>
> Maybe I celebrated a bit too early.  There is still one instance that
> is not matching...

Probably it's a parse error.

Try putting the following in your semantic patch, egin the metavariable
list of macros_noargs:

iterator name with_intel_display_power_if_enabled;

If that is still not sufficient, try running

spatch --parse-c file.c

for the file of interest and see if it says BAD or bad on the lines of the
function that you expect should be matched.

julia

>
> I currently have these rules:
>
> @macros_noargs@
> identifier m;
> expression e =~ "dev_priv";
> @@
> #define m <+...e...+>
>
> @nested_macros@
> identifier macros_noargs.m;
> identifier nm;
> identifier list il;
> @@
> #define nm(il) <+...m...+>
>
> @@
> identifier nested_macros.nm;
> identifier dev_priv, f;
> expression list el;
> @@
> f(...) {
> 	...
> 	struct drm_i915_private *dev_priv = ...;
>
> 	<+...
> 	nm(
> +	dev_priv,
> 	el)
> 	...+>
> }
>
> @@
> identifier nested_macros.nm;
> identifier dev_priv, f;
> expression list el;
> @@
> f(..., struct drm_i915_private *dev_priv, ...) {
> 	<+...
> 	nm(
> +	dev_priv,
> 	el)
> 	...+>
> }
>
> And then we have this function in
> drivers/gpu/drm/i915/display/intel_display.c:
>
> void vlv_wait_port_ready(struct drm_i915_private *dev_priv,
> 			 struct intel_digital_port *dig_port,
> 			 unsigned int expected_mask)
> {
> [...]
> 	switch (dig_port->base.port) {
> 	default:
> 		MISSING_CASE(dig_port->base.port);
> 		fallthrough;
> 	case PORT_B:
> 		port_mask = DPLL_PORTB_READY_MASK;
> 		dpll_reg = DPLL(0);
> 		break;
> 	case PORT_C:
> 		port_mask = DPLL_PORTC_READY_MASK;
> 		dpll_reg = DPLL(0);
> 		expected_mask <<= 4;
> 		break;
> [...]
> }
>
> The DPLL macro is defined like this (in
> drivers/gpu/drm/i915/display/i915_reg.h):
>
> #define _DPLL_A (DISPLAY_MMIO_BASE(dev_priv) + 0x6014)
> #define _DPLL_B (DISPLAY_MMIO_BASE(dev_priv) + 0x6018)
> #define _CHV_DPLL_C (DISPLAY_MMIO_BASE(dev_priv) + 0x6030)
> #define DPLL(pipe) _MMIO_PIPE3((pipe), _DPLL_A, _DPLL_B, _CHV_DPLL_C)
>
>
> So it should match like the other instances, but it doesn't.  I copied
> the macro definition and the function to stand-alone files (i.e.
> without the rest of the code) and it matches, but in the real code,
> running cocci like this, it doesn't:
>
> ~/public/coccinelle/spatch.opt --sp-file ~/dev_priv_i915.spatch --all-includes intel_display.c
>
> I noticed some parsing errors when using --debug (output attached), so
> maybe there's some parsing issues with the real file that prevents the
> rule from applying?
>
> Any clues?
>
> --
> Cheers,
> Luca.
>

Re: [cocci] Searching for special function implementations with SmPL

[Luca Coelho]

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

On Mon, 2023-01-30 at 09:56 +0100, Julia Lawall wrote:
> 
> On Mon, 30 Jan 2023, Luca Coelho wrote:
> 
> > On Mon, 2023-01-30 at 09:37 +0100, Julia Lawall wrote:
> > > > Sorry, false alarm.  I was running spatch by itself on an inner
> > > > directory (.../i915/display), but when I used find, I was using
> > > > .../i915, so there was one more match happening there.
> > > > 
> > > > So, it seems that the latest head _does_ work fine! And I'm gettign
> > > > all
> > > > the matches and changes that I expect.  Thanks!
> > > 
> > > Great news :)
> > 
> > Maybe I celebrated a bit too early.  There is still one instance that
> > is not matching...
> 
> Probably it's a parse error.
> 
> Try putting the following in your semantic patch, egin the metavariable
> list of macros_noargs:
> 
> iterator name with_intel_display_power_if_enabled;

I added it to the rule, like this:

@macros_noargs@
iterator name with_intel_display_power_if_enabled;
identifier m;
expression e =~ "dev_priv";
@@
#define m <+...e...+>


> If that is still not sufficient, try running
> 
> spatch --parse-c file.c
> 
> for the file of interest and see if it says BAD or bad on the lines of the
> function that you expect should be matched.

There are still lots of BADs and bads.  Output of --parse-c attached.

--
Luca.

[-- Attachment #2: output.txt --]
[-- Type: text/plain, Size: 18243 bytes --]

init_defs_builtins: /usr/lib/coccinelle/standard.h
Warning: PARSING: type defaults to 'int'; value = [((((0, 2)))); (Tag1 ("", (("", 0, 0, 0, ""), -1)), (0), ((0, 0, 0, 0)), 0, (3))]
Warning: PARSING: type defaults to 'int'; value = [((((0, 2)))); (Tag1 ("", (("", 0, 0, 0, ""), -1)), (0), ((0, 0, 0, 0)), 0, (3))]
Warning: PARSING: type defaults to 'int'; value = [((((0, 2)))); (Tag1 ("", (("", 0, 0, 0, ""), -1)), (0), ((0, 0, 0, 0)), 0, (3))]
Warning: PARSING: type defaults to 'int'; value = [((((0, 2)))); (Tag1 ("", (("", 0, 0, 0, ""), -1)), (0), ((0, 0, 0, 0)), 0, (3))]
Warning: PARSING: type defaults to 'int'; value = [((((0, 2)))); (Tag1 ("", (("", 0, 0, 0, ""), -1)), (0), ((0, 0, 0, 0)), 0, (3))]
Warning: PARSING: type defaults to 'int'; value = [((((0, 2)))); (Tag1 ("", (("", 0, 0, 0, ""), -1)), (0), ((0, 0, 0, 0)), 0, (3))]
Warning: PARSING: type defaults to 'int'; value = [((((0, 2)))); (Tag1 ("", (("", 0, 0, 0, ""), -1)), (0), ((0, 0, 0, 0)), 0, (3))]
Warning: PARSING: type defaults to 'int'; value = [((((0, 2)))); (Tag1 ("", (("", 0, 0, 0, ""), -1)), (0), ((0, 0, 0, 0)), 0, (3))]
Warning: PARSING: type defaults to 'int'; value = [((((0, 2)))); (Tag1 ("", (("", 0, 0, 0, ""), -1)), (0), ((0, 0, 0, 0)), 0, (3))]
Warning: PARSING: type defaults to 'int'; value = [((((0, 2)))); (Tag1 ("", (("", 0, 0, 0, ""), -1)), (0), ((0, 0, 0, 0)), 0, (3))]
Warning: PARSING: type defaults to 'int'; value = [((((0, 2)))); (Tag1 ("", (("", 0, 0, 0, ""), -1)), (0), ((0, 0, 0, 0)), 0, (3))]
Warning: PARSING: type defaults to 'int'; value = [((((0, 2)))); (Tag1 ("", (("", 0, 0, 0, ""), -1)), (0), ((0, 0, 0, 0)), 0, (3))]

PARSING: intel_display.c
(ONCE) CPP-MACRO: found known macro = KERN_DEBUG
(ONCE) CPP-MACRO: found known macro = KERN_ERR
(ONCE) CPP-MACRO: found known macro = __printf
including ./g4x_dp.h
including ./g4x_hdmi.h
including ./hsw_ips.h
including ./i9xx_plane.h
including ./icl_dsi.h
including ./intel_acpi.h
including ./intel_atomic.h
including ./intel_atomic_plane.h
including ./intel_audio.h
including ./intel_bw.h
TYPEDEF:_handle_typedef=false. Not normal if don't come from exn
TYPEDEF:_handle_typedef=false. Not normal if don't come from exn
including ./intel_cdclk.h
TYPEDEF:_handle_typedef=false. Not normal if don't come from exn
TYPEDEF:_handle_typedef=false. Not normal if don't come from exn
including ./intel_color.h
including ./intel_crt.h
including ./intel_crtc.h
including ./intel_crtc_state_dump.h
including ./intel_ddi.h
including ./intel_de.h
including ./intel_display_debugfs.h
including ./intel_display_power.h
(ONCE) CPP-MACRO: found known macro = DECLARE_BITMAP
ERROR-RECOV: found sync end of #define, line 162
parsing pass2: try again
ERROR-RECOV: found sync end of #define, line 162
parse error 
 = File "./intel_display_power.h", line 162, column 51, charpos = 4051
  around = '',
  whole content = 		for_each_if(test_bit((__domain), (__mask)->bits))
badcount: 4
bad: };
bad: 
bad: #define for_each_power_domain(__domain, __mask)				\
bad: 	for ((__domain) = 0; (__domain) < POWER_DOMAIN_NUM; (__domain)++)	\
BAD:!!!!! 		for_each_if(test_bit((__domain), (__mask)->bits))
ERROR-RECOV: found sync end of #define, line 282
parsing pass2: try again
ERROR-RECOV: found sync end of #define, line 282
parse error 
 = File "./intel_display_power.h", line 282, column 70, charpos = 8858
  around = '',
  whole content = 	     intel_display_power_put_async((i915), (domain), (wf)), (wf) = 0)
badcount: 4
bad: 			     u8 req_slices);
bad: 
bad: #define with_intel_display_power(i915, domain, wf) \
bad: 	for ((wf) = intel_display_power_get((i915), (domain)); (wf); \
BAD:!!!!! 	     intel_display_power_put_async((i915), (domain), (wf)), (wf) = 0)
ERROR-RECOV: found sync end of #define, line 286
parsing pass2: try again
ERROR-RECOV: found sync end of #define, line 286
parse error 
 = File "./intel_display_power.h", line 286, column 70, charpos = 9069
  around = '',
  whole content = 	     intel_display_power_put_async((i915), (domain), (wf)), (wf) = 0)
badcount: 4
bad: 	     intel_display_power_put_async((i915), (domain), (wf)), (wf) = 0)
bad: 
bad: #define with_intel_display_power_if_enabled(i915, domain, wf) \
bad: 	for ((wf) = intel_display_power_get_if_enabled((i915), (domain)); (wf); \
BAD:!!!!! 	     intel_display_power_put_async((i915), (domain), (wf)), (wf) = 0)
including ./intel_display_types.h
TYPEDEF:_handle_typedef=false. Not normal if don't come from exn
TYPEDEF:_handle_typedef=false. Not normal if don't come from exn
TYPEDEF:_handle_typedef=false. Not normal if don't come from exn
TYPEDEF:_handle_typedef=false. Not normal if don't come from exn
TYPEDEF:_handle_typedef=false. Not normal if don't come from exn
TYPEDEF:_handle_typedef=false. Not normal if don't come from exn
TYPEDEF:_handle_typedef=false. Not normal if don't come from exn
TYPEDEF:_handle_typedef=false. Not normal if don't come from exn
TYPEDEF:_handle_typedef=false. Not normal if don't come from exn
TYPEDEF:_handle_typedef=false. Not normal if don't come from exn
TYPEDEF:_handle_typedef=false. Not normal if don't come from exn
TYPEDEF:_handle_typedef=false. Not normal if don't come from exn
TYPEDEF:_handle_typedef=false. Not normal if don't come from exn
TYPEDEF:_handle_typedef=false. Not normal if don't come from exn
including ./intel_dmc.h
including ./intel_dp.h
including ./intel_dp_link_training.h
including ./intel_dp_mst.h
including ./intel_dpio_phy.h
including ./intel_dpll.h
including ./intel_dpll_mgr.h
including ./intel_dpt.h
including ./intel_drrs.h
including ./intel_dsi.h
TYPEDEF:_handle_typedef=false. Not normal if don't come from exn
TYPEDEF:_handle_typedef=false. Not normal if don't come from exn
including ./intel_dvo.h
including ./intel_fb.h
including ./intel_fbc.h
including ./intel_fbdev.h
including ./intel_fdi.h
including ./intel_fifo_underrun.h
including ./intel_frontbuffer.h
including ./intel_gmbus.h
including ./intel_hdcp.h
including ./intel_hdmi.h
including ./intel_hotplug.h
including ./intel_hti.h
including ./intel_lvds.h
including ./intel_modeset_setup.h
including ./intel_modeset_verify.h
including ./intel_overlay.h
including ./intel_panel.h
including ./intel_pch_display.h
including ./intel_pch_refclk.h
including ./intel_pipe_crc.h
including ./intel_plane_initial.h
including ./intel_pps.h
ERROR-RECOV: found sync end of #define, line 24
parsing pass2: try again
ERROR-RECOV: found sync end of #define, line 24
parse error 
 = File "./intel_pps.h", line 24, column 75, charpos = 574
  around = '',
  whole content = 	for ((wf) = intel_pps_lock(dp); (wf); (wf) = intel_pps_unlock((dp), (wf)))
badcount: 3
bad: intel_wakeref_t intel_pps_unlock(struct intel_dp *intel_dp, intel_wakeref_t wakeref);
bad: 
bad: #define with_intel_pps_lock(dp, wf)						\
BAD:!!!!! 	for ((wf) = intel_pps_lock(dp); (wf); (wf) = intel_pps_unlock((dp), (wf)))
including ./intel_psr.h
including ./intel_quirks.h
including ./intel_sdvo.h
including ./intel_snps_phy.h
including ./intel_sprite.h
including ./intel_tc.h
including ./intel_tv.h
including ./intel_vblank.h
including ./intel_vdsc.h
including ./intel_vga.h
including ./intel_vrr.h
including ./skl_scaler.h
including ./skl_universal_plane.h
including ./skl_watermark.h
TYPEDEF:_handle_typedef=false. Not normal if don't come from exn
TYPEDEF:_handle_typedef=false. Not normal if don't come from exn
including ./vlv_dsi.h
including ./vlv_dsi_pll.h
including ./vlv_dsi_regs.h
(ONCE) CPP-MACRO: found foreach: for_each_intel_plane_on_crtc
(ONCE) CPP-MACRO: found foreach: drm_for_each_plane_mask
(ONCE) CPP-MACRO: found foreach: for_each_new_crtc_in_state
(ONCE) CPP-MACRO: found foreach: drm_for_each_crtc
TYPEDEF:_handle_typedef=false. Not normal if don't come from exn
(ONCE) CPP-MACRO: found foreach: for_each_new_connector_in_state
(ONCE) CPP-MACRO: found foreach: for_each_new_intel_plane_in_state
(ONCE) CPP-MACRO: found foreach: for_each_old_intel_plane_in_state
(ONCE) CPP-MACRO: found foreach: for_each_oldnew_intel_crtc_in_state
(ONCE) CPP-MACRO: found foreach: for_each_old_connector_in_state
(ONCE) CPP-MACRO: found foreach: drm_for_each_encoder_mask
(ONCE) CPP-MACRO: found foreach: for_each_power_domain
TYPEDEF:_handle_typedef=false. Not normal if don't come from exn
ERROR-RECOV: found sync '}' at line 3711
parsing pass2: try again
ERROR-RECOV: found sync '}' at line 3711
parsing pass3: try again
ERROR-RECOV: found sync '}' at line 3711
parse error 
 = File "intel_display.c", line 3708, column 2, charpos = 111316
  around = 'tmp',
  whole content = 		tmp = intel_de_read(dev_priv, TRANS_DDI_FUNC_CTL(cpu_transcoder));
badcount: 15
bad: }
bad: 
bad: static bool transcoder_ddi_func_is_enabled(struct drm_i915_private *dev_priv,
bad: 					   enum transcoder cpu_transcoder)
bad: {
bad: 	enum intel_display_power_domain power_domain;
bad: 	intel_wakeref_t wakeref;
bad: 	u32 tmp = 0;
bad: 
bad: 	power_domain = POWER_DOMAIN_TRANSCODER(cpu_transcoder);
bad: 
bad: 	with_intel_display_power_if_enabled(dev_priv, power_domain, wakeref)
BAD:!!!!! 		tmp = intel_de_read(dev_priv, TRANS_DDI_FUNC_CTL(cpu_transcoder));
bad: 
bad: 	return tmp & TRANS_DDI_FUNC_ENABLE;
bad: }
(ONCE) CPP-MACRO: found foreach: for_each_intel_crtc_in_pipe_mask
ERROR-RECOV: found sync '}' at line 3758
parsing pass2: try again
ERROR-RECOV: found sync '}' at line 3758
parsing pass3: try again
ERROR-RECOV: found sync '}' at line 3758
parse error 
 = File "intel_display.c", line 3728, column 71, charpos = 111947
  around = '{',
  whole content = 		with_intel_display_power_if_enabled(dev_priv, power_domain, wakeref) {
badcount: 47
bad: }
bad: 
bad: static void enabled_bigjoiner_pipes(struct drm_i915_private *dev_priv,
bad: 				    u8 *master_pipes, u8 *slave_pipes)
bad: {
bad: 	struct intel_crtc *crtc;
bad: 
bad: 	*master_pipes = 0;
bad: 	*slave_pipes = 0;
bad: 
bad: 	for_each_intel_crtc_in_pipe_mask(&dev_priv->drm, crtc,
bad: 					 bigjoiner_pipes(dev_priv)) {
bad: 		enum intel_display_power_domain power_domain;
bad: 		enum pipe pipe = crtc->pipe;
bad: 		intel_wakeref_t wakeref;
bad: 
bad: 		power_domain = intel_dsc_power_domain(crtc, (enum transcoder) pipe);
BAD:!!!!! 		with_intel_display_power_if_enabled(dev_priv, power_domain, wakeref) {
bad: 			u32 tmp = intel_de_read(dev_priv, ICL_PIPE_DSS_CTL1(pipe));
bad: 
bad: 			if (!(tmp & BIG_JOINER_ENABLE))
bad: 				continue;
bad: 
bad: 			if (tmp & MASTER_BIG_JOINER_ENABLE)
bad: 				*master_pipes |= BIT(pipe);
bad: 			else
bad: 				*slave_pipes |= BIT(pipe);
bad: 		}
bad: 
bad: 		if (DISPLAY_VER(dev_priv) < 13)
bad: 			continue;
bad: 
bad: 		power_domain = POWER_DOMAIN_PIPE(pipe);
bad: 		with_intel_display_power_if_enabled(dev_priv, power_domain, wakeref) {
bad: 			u32 tmp = intel_de_read(dev_priv, ICL_PIPE_DSS_CTL1(pipe));
bad: 
bad: 			if (tmp & UNCOMPRESSED_JOINER_MASTER)
bad: 				*master_pipes |= BIT(pipe);
bad: 			if (tmp & UNCOMPRESSED_JOINER_SLAVE)
bad: 				*slave_pipes |= BIT(pipe);
bad: 		}
bad: 	}
bad: 
bad: 	/* Bigjoiner pipes should always be consecutive master and slave */
bad: 	drm_WARN(&dev_priv->drm, *slave_pipes != *master_pipes << 1,
bad: 		 "Bigjoiner misconfigured (master pipes 0x%x, slave pipes 0x%x)\n",
bad: 		 *master_pipes, *slave_pipes);
bad: }
(ONCE) CPP-MACRO: found foreach: for_each_cpu_transcoder_masked
ERROR-RECOV: found sync '}' at line 3868
parsing pass2: try again
ERROR-RECOV: found sync '}' at line 3868
parsing pass3: try again
ERROR-RECOV: found sync '}' at line 3868
parse error 
 = File "intel_display.c", line 3823, column 3, charpos = 114767
  around = 'tmp',
  whole content = 			tmp = intel_de_read(dev_priv, TRANS_DDI_FUNC_CTL(cpu_transcoder));
badcount: 69
bad: }
bad: 
bad: static u8 hsw_enabled_transcoders(struct intel_crtc *crtc)
bad: {
bad: 	struct drm_device *dev = crtc->base.dev;
bad: 	struct drm_i915_private *dev_priv = to_i915(dev);
bad: 	u8 panel_transcoder_mask = hsw_panel_transcoders(dev_priv);
bad: 	enum transcoder cpu_transcoder;
bad: 	u8 master_pipes, slave_pipes;
bad: 	u8 enabled_transcoders = 0;
bad: 
bad: 	/*
bad: 	 * XXX: Do intel_display_power_get_if_enabled before reading this (for
bad: 	 * consistency and less surprising code; it's in always on power).
bad: 	 */
bad: 	for_each_cpu_transcoder_masked(dev_priv, cpu_transcoder,
bad: 				       panel_transcoder_mask) {
bad: 		enum intel_display_power_domain power_domain;
bad: 		intel_wakeref_t wakeref;
bad: 		enum pipe trans_pipe;
bad: 		u32 tmp = 0;
bad: 
bad: 		power_domain = POWER_DOMAIN_TRANSCODER(cpu_transcoder);
bad: 		with_intel_display_power_if_enabled(dev_priv, power_domain, wakeref)
BAD:!!!!! 			tmp = intel_de_read(dev_priv, TRANS_DDI_FUNC_CTL(cpu_transcoder));
bad: 
bad: 		if (!(tmp & TRANS_DDI_FUNC_ENABLE))
bad: 			continue;
bad: 
bad: 		switch (tmp & TRANS_DDI_EDP_INPUT_MASK) {
bad: 		default:
bad: 			drm_WARN(dev, 1,
bad: 				 "unknown pipe linked to transcoder %s\n",
bad: 				 transcoder_name(cpu_transcoder));
bad: 			fallthrough;
bad: 		case TRANS_DDI_EDP_INPUT_A_ONOFF:
bad: 		case TRANS_DDI_EDP_INPUT_A_ON:
bad: 			trans_pipe = PIPE_A;
bad: 			break;
bad: 		case TRANS_DDI_EDP_INPUT_B_ONOFF:
bad: 			trans_pipe = PIPE_B;
bad: 			break;
bad: 		case TRANS_DDI_EDP_INPUT_C_ONOFF:
bad: 			trans_pipe = PIPE_C;
bad: 			break;
bad: 		case TRANS_DDI_EDP_INPUT_D_ONOFF:
bad: 			trans_pipe = PIPE_D;
bad: 			break;
bad: 		}
bad: 
bad: 		if (trans_pipe == crtc->pipe)
bad: 			enabled_transcoders |= BIT(cpu_transcoder);
bad: 	}
bad: 
bad: 	/* single pipe or bigjoiner master */
bad: 	cpu_transcoder = (enum transcoder) crtc->pipe;
bad: 	if (transcoder_ddi_func_is_enabled(dev_priv, cpu_transcoder))
bad: 		enabled_transcoders |= BIT(cpu_transcoder);
bad: 
bad: 	/* bigjoiner slave -> consider the master pipe's transcoder as well */
bad: 	enabled_bigjoiner_pipes(dev_priv, &master_pipes, &slave_pipes);
bad: 	if (slave_pipes & BIT(crtc->pipe)) {
bad: 		cpu_transcoder = (enum transcoder)
bad: 			get_bigjoiner_master_pipe(crtc->pipe, master_pipes, slave_pipes);
bad: 		if (transcoder_ddi_func_is_enabled(dev_priv, cpu_transcoder))
bad: 			enabled_transcoders |= BIT(cpu_transcoder);
bad: 	}
bad: 
bad: 	return enabled_transcoders;
bad: }
(ONCE) CPP-MACRO: found foreach: for_each_port_masked
(ONCE) CPP-MACRO: found foreach: for_each_new_plane_in_state
(ONCE) CPP-MACRO: found foreach: for_each_intel_crtc
(ONCE) CPP-MACRO: found foreach: drm_for_each_connector_iter
(ONCE) CPP-TYPEDEF: promoting:(2) va_list on line 5442
(ONCE) CPP-MACRO: found foreach: for_each_new_intel_crtc_in_state
(ONCE) CPP-MACRO: found foreach: for_each_oldnew_intel_plane_in_state
(ONCE) CPP-MACRO: found foreach: llist_for_each_entry_safe
(ONCE) CPP-MACRO: found foreach: for_each_old_intel_crtc_in_state
(ONCE) CPP-MACRO: found foreach: for_each_intel_plane
(ONCE) CPP-MACRO: found foreach: for_each_intel_encoder
(ONCE) CPP-MACRO: found foreach: drm_for_each_plane
(ONCE) CPP-MACRO: found foreach: for_each_intel_encoder_mask
(ONCE) CPP-MACRO: found foreach: for_each_pipe
(ONCE) CPP-MACRO: found foreach: for_each_intel_connector_iter
passed:__printf ( 4 , 5 ) 
-----------------------------------------------------------------------
maybe 10 most problematic tokens
-----------------------------------------------------------------------
dev_priv: present in 5 parsing errors
example: 
       		power_domain = POWER_DOMAIN_TRANSCODER(cpu_transcoder);
       		with_intel_display_power_if_enabled(dev_priv, power_domain, wakeref)
       			tmp = intel_de_read(dev_priv, TRANS_DDI_FUNC_CTL(cpu_transcoder));
       
power_domain: present in 5 parsing errors
example: 
       		power_domain = POWER_DOMAIN_TRANSCODER(cpu_transcoder);
       		with_intel_display_power_if_enabled(dev_priv, power_domain, wakeref)
       			tmp = intel_de_read(dev_priv, TRANS_DDI_FUNC_CTL(cpu_transcoder));
       
cpu_transcoder: present in 3 parsing errors
example: 
       		power_domain = POWER_DOMAIN_TRANSCODER(cpu_transcoder);
       		with_intel_display_power_if_enabled(dev_priv, power_domain, wakeref)
       			tmp = intel_de_read(dev_priv, TRANS_DDI_FUNC_CTL(cpu_transcoder));
       
wakeref: present in 3 parsing errors
example: 
       		power_domain = POWER_DOMAIN_TRANSCODER(cpu_transcoder);
       		with_intel_display_power_if_enabled(dev_priv, power_domain, wakeref)
       			tmp = intel_de_read(dev_priv, TRANS_DDI_FUNC_CTL(cpu_transcoder));
       
with_intel_display_power_if_enabled: present in 3 parsing errors
example: 
       		power_domain = POWER_DOMAIN_TRANSCODER(cpu_transcoder);
       		with_intel_display_power_if_enabled(dev_priv, power_domain, wakeref)
       			tmp = intel_de_read(dev_priv, TRANS_DDI_FUNC_CTL(cpu_transcoder));
       
TRANS_DDI_FUNC_CTL: present in 2 parsing errors
example: 
       		power_domain = POWER_DOMAIN_TRANSCODER(cpu_transcoder);
       		with_intel_display_power_if_enabled(dev_priv, power_domain, wakeref)
       			tmp = intel_de_read(dev_priv, TRANS_DDI_FUNC_CTL(cpu_transcoder));
       
intel_de_read: present in 2 parsing errors
example: 
       		power_domain = POWER_DOMAIN_TRANSCODER(cpu_transcoder);
       		with_intel_display_power_if_enabled(dev_priv, power_domain, wakeref)
       			tmp = intel_de_read(dev_priv, TRANS_DDI_FUNC_CTL(cpu_transcoder));
       
tmp: present in 2 parsing errors
example: 
       		power_domain = POWER_DOMAIN_TRANSCODER(cpu_transcoder);
       		with_intel_display_power_if_enabled(dev_priv, power_domain, wakeref)
       			tmp = intel_de_read(dev_priv, TRANS_DDI_FUNC_CTL(cpu_transcoder));
       
POWER_DOMAIN_TRANSCODER: present in 1 parsing errors
example: 
       		power_domain = POWER_DOMAIN_TRANSCODER(cpu_transcoder);
       		with_intel_display_power_if_enabled(dev_priv, power_domain, wakeref)
       			tmp = intel_de_read(dev_priv, TRANS_DDI_FUNC_CTL(cpu_transcoder));
       
crtc: present in 1 parsing errors
example: 
       
       		power_domain = intel_dsc_power_domain(crtc, (enum transcoder) pipe);
       		with_intel_display_power_if_enabled(dev_priv, power_domain, wakeref) {
       			u32 tmp = intel_de_read(dev_priv, ICL_PIPE_DSS_CTL1(pipe));
-----------------------------------------------------------------------
NB total files = 1; perfect = 0; pbs = 1; timeout = 0; =========> 0%
nb good = 8908,  nb passed = 1 =========> 0.01% passed
nb good = 8908,  nb bad = 131 =========> 98.55% good or passed

Re: [cocci] Searching for special function implementations with SmPL

[Markus Elfring]

> Maybe I celebrated a bit too early.  There is still one instance that
> is not matching...
>
> I currently have these rules:


You present an additional SmPL rule.



> @@
> identifier nested_macros.nm;
> identifier dev_priv, f;
> expression list el;
> @@
> f(..., struct drm_i915_private *dev_priv, ...) {
> 	<+...
> 	nm(
> +	dev_priv,
> 	el)
> 	...+>
> }
>
> And then we have this function in
> drivers/gpu/drm/i915/display/intel_display.c:
>
> void vlv_wait_port_ready(struct drm_i915_private *dev_priv,
> 			 struct intel_digital_port *dig_port,
> 			 unsigned int expected_mask)

…

See also:
https://elixir.bootlin.com/linux/v6.2-rc5/source/drivers/gpu/drm/i915/display/intel_display.c#L497
https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/drivers/gpu/drm/i915/display/intel_display.c?h=v6.2-rc6#n497


> Any clues?


Can it matter to omit the search pattern “...,” for the first function parameter?

Will any additional SmPL disjunctions become relevant?


Regards,
Markus

Re: [cocci] Searching for special function implementations with SmPL

[Luca Coelho]

On Mon, 2023-01-30 at 10:34 +0100, Markus Elfring wrote:
> > Maybe I celebrated a bit too early.  There is still one instance
> > that
> > is not matching...
> > 
> > I currently have these rules:
> 
> 
> You present an additional SmPL rule.

Yes, this is evolving.  Now I'm trying to catch other instances.


> > @@
> > identifier nested_macros.nm;
> > identifier dev_priv, f;
> > expression list el;
> > @@
> > f(..., struct drm_i915_private *dev_priv, ...) {
> > 	<+...
> > 	nm(
> > +	dev_priv,
> > 	el)
> > 	...+>
> > }
> > 
> > And then we have this function in
> > drivers/gpu/drm/i915/display/intel_display.c:
> > 
> > void vlv_wait_port_ready(struct drm_i915_private *dev_priv,
> > 			 struct intel_digital_port *dig_port,
> > 			 unsigned int expected_mask)
> 
> …
> 
> See also:
> https://elixir.bootlin.com/linux/v6.2-
> rc5/source/drivers/gpu/drm/i915/display/intel_display.c#L497
> https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tr
> ee/drivers/gpu/drm/i915/display/intel_display.c?h=v6.2-rc6#n497
> 
> 
> > Any clues?
> 
> 
> Can it matter to omit the search pattern “...,” for the first
> function parameter?

I tried it, but it didn't help.


> Will any additional SmPL disjunctions become relevant?

I don't think the problem is in the rule, since this works on an
isolated version of the function and macro definitions.

--
Luca.

Re: [cocci] Searching for special function implementations with SmPL

[Markus Elfring]

> I don't think the problem is in the rule, since this works on an
> isolated version of the function and macro definitions.


Would update candidates be found by using the SmPL asterisk functionality?

Regards,
Markus

Re: [cocci] Searching for special function implementations with SmPL

[Luca Coelho]

On Mon, 2023-01-30 at 10:50 +0100, Markus Elfring wrote:
> > I don't think the problem is in the rule, since this works on an
> > isolated version of the function and macro definitions.
> 
> 
> Would update candidates be found by using the SmPL asterisk
> functionality?

Sorry, I don't think I'm aware of this functionality.

--
Luca.

Re: [cocci] Searching for special function implementations with SmPL

[Julia Lawall]

On Mon, 30 Jan 2023, Luca Coelho wrote:

> On Mon, 2023-01-30 at 10:50 +0100, Markus Elfring wrote:
> > > I don't think the problem is in the rule, since this works on an
> > > isolated version of the function and macro definitions.
> >
> >
> > Would update candidates be found by using the SmPL asterisk
> > functionality?
>
> Sorry, I don't think I'm aware of this functionality.

It's for searching.  It only requires the existence of an execution path
that matches the pattern, rather than requiring that all execution paths
match the pattern.

julia

Re: [cocci] Searching for special function implementations with SmPL

[Markus Elfring]

>> Would update candidates be found by using the SmPL asterisk
>> functionality?
> Sorry, I don't think I'm aware of this functionality.


I imagine that you can become interested in the term “semantic match”
for further use cases.

See also:
https://gitlab.inria.fr/coccinelle/coccinelle/-/blob/b9603af4eca7f4c771d57a3861855332e9bb1c4c/docs/manual/cocci_syntax.tex#L1208
https://coccinelle.gitlabpages.inria.fr/website/docs/main_grammar005.html

Regards,
Markus

Re: [cocci] Searching for special function implementations with SmPL

[Julia Lawall]

It doesn't find the file with the definition.  You may need to give more
paths.

I have the impression that the result is improved with

-I drivers/gpu/drm/i915

Maybe -I drivers/gpu/drm/i915/display is necessary also.  If you add the
argument --relax-include-path then just -I drivers/gpu/drm/i915 may be
sufficient.  With that option, it will just hunt around in and under the
various include paths for a unique file that has the required name.

julia

Re: [cocci] Searching for special function implementations with SmPL

[Luca Coelho]

On Mon, 2023-01-30 at 11:47 +0100, Julia Lawall wrote:
> It doesn't find the file with the definition.  You may need to give more
> paths.
> 
> I have the impression that the result is improved with
> 
> -I drivers/gpu/drm/i915
> 
> Maybe -I drivers/gpu/drm/i915/display is necessary also.  If you add the
> argument --relax-include-path then just -I drivers/gpu/drm/i915 may be
> sufficient.  With that option, it will just hunt around in and under the
> various include paths for a unique file that has the required name.

Alright! That _does_ improve things! Now I can see lots of DPLL matches
in that file!

Thanks again. 🙂

--
Cheers,
Luca.

Re: [cocci] Searching for special function implementations with SmPL

[Markus Elfring]

>> It doesn't find the file with the definition.  You may need to give more
>> paths.
>>
>> I have the impression that the result is improved with
>>
>> -I drivers/gpu/drm/i915
>>
>> Maybe -I drivers/gpu/drm/i915/display is necessary also.  If you add the
>> argument --relax-include-path then just -I drivers/gpu/drm/i915 may be
>> sufficient.  With that option, it will just hunt around in and under the
>> various include paths for a unique file that has the required name.
> Alright! That _does_ improve things! Now I can see lots of DPLL matches
> in that file!


Would you like to compare this test result with data which can be provided by
the script “https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/scripts/coccicheck?h=v6.2-rc6#n5”?
https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/Documentation/dev-tools/coccinelle.rst?h=v6.2-rc6#n151

Regards,
Markus

Re: [cocci] Searching for special function implementations with SmPL

[Luca Coelho]

On Mon, 2023-01-30 at 12:59 +0200, Luca Coelho wrote:
> On Mon, 2023-01-30 at 11:47 +0100, Julia Lawall wrote:
> > It doesn't find the file with the definition.  You may need to give more
> > paths.
> > 
> > I have the impression that the result is improved with
> > 
> > -I drivers/gpu/drm/i915
> > 
> > Maybe -I drivers/gpu/drm/i915/display is necessary also.  If you add the
> > argument --relax-include-path then just -I drivers/gpu/drm/i915 may be
> > sufficient.  With that option, it will just hunt around in and under the
> > various include paths for a unique file that has the required name.
> 
> Alright! That _does_ improve things! Now I can see lots of DPLL matches
> in that file!

These files I'm trying to parse are so complex that I keep bumping into
other parsing errors.  Here's one of them:

parse error 
 = File "./drivers/gpu/drm/i915/i915_drv.h", line 385, column 1, charpos = 9644
  around = 'for',
  whole content =       for ((id__) = 0; \
badcount: 7
bad: }
bad: 
bad: /* Simple iterator over all initialised engines */
bad: #define for_each_engine(engine__, dev_priv__, id__) \
BAD:!!!!!       for ((id__) = 0; \
bad:         (id__) < I915_NUM_ENGINES; \
bad:         (id__)++) \
bad:            for_each_if ((engine__) = (dev_priv__)->engine[(id__)])
ERROR-RECOV: found sync end of #define, line 395


I believe the parser is getting confused by an iterator inside an
iterator's definition... I already tried to add them both with the
"iterator name" directive, but it didn't help...

Any idea what I can do about this?

--
Cheers,
Luca.

Re: [cocci] Searching for special function implementations with SmPL

[Luca Coelho]

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

On Tue, 2023-01-31 at 17:57 +0200, Luca Coelho wrote:
> On Mon, 2023-01-30 at 12:59 +0200, Luca Coelho wrote:
> > On Mon, 2023-01-30 at 11:47 +0100, Julia Lawall wrote:
> > > It doesn't find the file with the definition.  You may need to give more
> > > paths.
> > > 
> > > I have the impression that the result is improved with
> > > 
> > > -I drivers/gpu/drm/i915
> > > 
> > > Maybe -I drivers/gpu/drm/i915/display is necessary also.  If you add the
> > > argument --relax-include-path then just -I drivers/gpu/drm/i915 may be
> > > sufficient.  With that option, it will just hunt around in and under the
> > > various include paths for a unique file that has the required name.
> > 
> > Alright! That _does_ improve things! Now I can see lots of DPLL matches
> > in that file!
> 
> These files I'm trying to parse are so complex that I keep bumping into
> other parsing errors.  Here's one of them:
> 
> parse error 
>  = File "./drivers/gpu/drm/i915/i915_drv.h", line 385, column 1, charpos = 9644
>   around = 'for',
>   whole content =       for ((id__) = 0; \
> badcount: 7
> bad: }
> bad: 
> bad: /* Simple iterator over all initialised engines */
> bad: #define for_each_engine(engine__, dev_priv__, id__) \
> BAD:!!!!!       for ((id__) = 0; \
> bad:         (id__) < I915_NUM_ENGINES; \
> bad:         (id__)++) \
> bad:            for_each_if ((engine__) = (dev_priv__)->engine[(id__)])
> ERROR-RECOV: found sync end of #define, line 395
> 
> 
> I believe the parser is getting confused by an iterator inside an
> iterator's definition... I already tried to add them both with the
> "iterator name" directive, but it didn't help...
> 
> Any idea what I can do about this?

Oh, and here's the full debugging output.

--
Luca.

[-- Attachment #2: output.txt --]
[-- Type: text/plain, Size: 11361 bytes --]

init_defs_builtins: /home/luca/public/coccinelle/standard.h
-----------------------------------------------------------------------
processing semantic patch file: /home/luca/dev_priv_i915.spatch
with isos from: /home/luca/public/coccinelle/standard.iso
-----------------------------------------------------------------------
@macros_noargs@
iterator name with_intel_display_power_if_enabled;
iterator name with_intel_display_power;
iterator name for_each_power_domain;
iterator name with_intel_pps_lock;
iterator name for_each_pipe;
iterator name for_each_intel_encoder;
//iterator name for_each_engine;
iterator name for_each_engine_masked;
iterator name for_each_if;


iterator name for_each_engine;
iterator name for_each_engine_masked;
iterator name for_each_uabi_engine;
iterator name for_each_uabi_class_engine;
iterator name __for_each_sgt_daddr;
iterator name for_each_sgt_page;
iterator name priolist_for_each_request;
iterator name priolist_for_each_request_consume;
iterator name for_each_waiter;
iterator name for_each_signaler;
iterator name for_each_until;
iterator name for_each_ggtt_vma;
iterator name for_each_memory_region;
iterator name for_each_fw_domain_masked;
iterator name for_each_fw_domain;


identifier m;
expression e =~ "dev_priv";
@@
#define m <+...e...+>

@nested_macros@
identifier macros_noargs.m;
identifier nm;
identifier list il;
@@
#define nm(il) <+...m...+>

@@
identifier nested_macros.nm;
identifier dev_priv, f;
expression list el;
@@
f(...) {
	...
	struct drm_i915_private *dev_priv = ...;

	<+...
	nm(
+	dev_priv,	
	el)
	...+>
}

@@
identifier nested_macros.nm;
identifier dev_priv, f;
expression list el;
@@
f(..., struct drm_i915_private *dev_priv, ...) {
	<+...
	nm(
+	dev_priv,
	el)
	...+>
}

-----------------------------------------------------------------------
let's go
-----------------------------------------------------------------------
-----------------------------------------------------------------------
-----------------------------------------------------------------------
macros_noargs = 
-----------------------------------------------------------------------
binding in = []
binding relevant in = []
-----------------------------------------------------------------------
nested_macros = 
-----------------------------------------------------------------------
binding in = []
binding relevant in = []
-----------------------------------------------------------------------
rule starting on line 42 = 
-----------------------------------------------------------------------
binding in = []
binding relevant in = []
-----------------------------------------------------------------------
rule starting on line 58 = 
-----------------------------------------------------------------------
binding in = []
binding relevant in = []
-----------------------------------------------------------------------
Finished
-----------------------------------------------------------------------
HANDLING: ./drivers/gpu/drm/i915/display/intel_display_power.c
remapping: for_each_engine to an ident in macro name
remapping: for_each_engine_masked to an ident in macro name
remapping: for_each_uabi_engine to an ident in macro name
remapping: for_each_uabi_class_engine to an ident in macro name
ERROR-RECOV: found sync end of #define, line 388
parsing pass2: try again
ERROR-RECOV: found sync end of #define, line 388
parse error 
 = File "./drivers/gpu/drm/i915/i915_drv.h", line 385, column 1, charpos = 9644
  around = 'for',
  whole content = 	for ((id__) = 0; \
badcount: 7
bad: }
bad: 
bad: /* Simple iterator over all initialised engines */
bad: #define for_each_engine(engine__, dev_priv__, id__) \
BAD:!!!!! 	for ((id__) = 0; \
bad: 	     (id__) < I915_NUM_ENGINES; \
bad: 	     (id__)++) \
bad: 		for_each_if ((engine__) = (dev_priv__)->engine[(id__)])
ERROR-RECOV: found sync end of #define, line 395
parsing pass2: try again
ERROR-RECOV: found sync end of #define, line 395
parse error 
 = File "./drivers/gpu/drm/i915/i915_drv.h", line 392, column 1, charpos = 9895
  around = 'for',
  whole content = 	for ((tmp__) = (mask__) & (gt__)->info.engine_mask; \
badcount: 7
bad: 		for_each_if ((engine__) = (dev_priv__)->engine[(id__)])
bad: 
bad: /* Iterator over subset of engines selected by mask */
bad: #define for_each_engine_masked(engine__, gt__, mask__, tmp__) \
BAD:!!!!! 	for ((tmp__) = (mask__) & (gt__)->info.engine_mask; \
bad: 	     (tmp__) ? \
bad: 	     ((engine__) = (gt__)->engine[__mask_next_bit(tmp__)]), 1 : \
bad: 	     0;)
ERROR-RECOV: found sync end of #define, line 403
parsing pass2: try again
ERROR-RECOV: found sync end of #define, line 403
parse error 
 = File "./drivers/gpu/drm/i915/i915_drv.h", line 401, column 1, charpos = 10182
  around = 'for',
  whole content = 	for ((engine__) = rb_to_uabi_engine(rb_first(&(i915__)->uabi_engines));\
badcount: 5
bad: 	rb_entry_safe(rb, struct intel_engine_cs, uabi_node)
bad: 
bad: #define for_each_uabi_engine(engine__, i915__) \
BAD:!!!!! 	for ((engine__) = rb_to_uabi_engine(rb_first(&(i915__)->uabi_engines));\
bad: 	     (engine__); \
bad: 	     (engine__) = rb_to_uabi_engine(rb_next(&(engine__)->uabi_node)))
ERROR-RECOV: found sync end of #define, line 408
parsing pass2: try again
ERROR-RECOV: found sync end of #define, line 408
parse error 
 = File "./drivers/gpu/drm/i915/i915_drv.h", line 406, column 1, charpos = 10412
  around = 'for',
  whole content = 	for ((engine__) = intel_engine_lookup_user((i915__), (class__), 0); \
badcount: 5
bad: 	     (engine__) = rb_to_uabi_engine(rb_next(&(engine__)->uabi_node)))
bad: 
bad: #define for_each_uabi_class_engine(engine__, class__, i915__) \
BAD:!!!!! 	for ((engine__) = intel_engine_lookup_user((i915__), (class__), 0); \
bad: 	     (engine__) && (engine__)->uabi_class == (class__); \
bad: 	     (engine__) = rb_to_uabi_engine(rb_next(&(engine__)->uabi_node)))
ERROR-RECOV: found sync end of #define, line 662
parsing pass2: try again
ERROR-RECOV: found sync end of #define, line 662
parse error 
 = File "./drivers/gpu/drm/i915/i915_drv.h", line 662, column 40, charpos = 21985
  around = ')',
  whole content = 	 IS_GRAPHICS_STEP(__i915, since, until))
badcount: 4
bad: 	 IS_GRAPHICS_STEP(__i915, since, until))
bad: 
bad: #define IS_TGL_GRAPHICS_STEP(__i915, since, until) \
bad: 	(IS_TIGERLAKE(__i915) && !IS_TGL_UY(__i915)) && \
BAD:!!!!! 	 IS_GRAPHICS_STEP(__i915, since, until))
remapping: for_each_power_domain to an ident in macro name
remapping: with_intel_display_power to an ident in macro name
remapping: with_intel_display_power_if_enabled to an ident in macro name
ERROR-RECOV: found sync end of #define, line 162
parsing pass2: try again
ERROR-RECOV: found sync end of #define, line 162
parse error 
 = File "./drivers/gpu/drm/i915/display/intel_display_power.h", line 161, column 1, charpos = 3932
  around = 'for',
  whole content = 	for ((__domain) = 0; (__domain) < POWER_DOMAIN_NUM; (__domain)++)	\
badcount: 4
bad: };
bad: 
bad: #define for_each_power_domain(__domain, __mask)				\
BAD:!!!!! 	for ((__domain) = 0; (__domain) < POWER_DOMAIN_NUM; (__domain)++)	\
bad: 		for_each_if(test_bit((__domain), (__mask)->bits))
ERROR-RECOV: found sync end of #define, line 282
parsing pass2: try again
ERROR-RECOV: found sync end of #define, line 282
parse error 
 = File "./drivers/gpu/drm/i915/display/intel_display_power.h", line 281, column 1, charpos = 8725
  around = 'for',
  whole content = 	for ((wf) = intel_display_power_get((i915), (domain)); (wf); \
badcount: 4
bad: 			     u8 req_slices);
bad: 
bad: #define with_intel_display_power(i915, domain, wf) \
BAD:!!!!! 	for ((wf) = intel_display_power_get((i915), (domain)); (wf); \
bad: 	     intel_display_power_put_async((i915), (domain), (wf)), (wf) = 0)
ERROR-RECOV: found sync end of #define, line 286
parsing pass2: try again
ERROR-RECOV: found sync end of #define, line 286
parse error 
 = File "./drivers/gpu/drm/i915/display/intel_display_power.h", line 285, column 1, charpos = 8925
  around = 'for',
  whole content = 	for ((wf) = intel_display_power_get_if_enabled((i915), (domain)); (wf); \
badcount: 4
bad: 	     intel_display_power_put_async((i915), (domain), (wf)), (wf) = 0)
bad: 
bad: #define with_intel_display_power_if_enabled(i915, domain, wf) \
BAD:!!!!! 	for ((wf) = intel_display_power_get_if_enabled((i915), (domain)); (wf); \
bad: 	     intel_display_power_put_async((i915), (domain), (wf)), (wf) = 0)
ERROR-RECOV: found sync end of #define, line 20
parsing pass2: try again
ERROR-RECOV: found sync end of #define, line 20
parse error 
 = File "./drivers/gpu/drm/i915/display/intel_display_power_well.h", line 20, column 23, charpos = 588
  around = '',
  whole content = 	     (__power_well)++)
badcount: 6
bad: struct i915_power_well;
bad: 
bad: #define for_each_power_well(__dev_priv, __power_well)				\
bad: 	for ((__power_well) = (__dev_priv)->display.power.domains.power_wells;	\
bad: 	     (__power_well) - (__dev_priv)->display.power.domains.power_wells <	\
bad: 		(__dev_priv)->display.power.domains.power_well_count;		\
BAD:!!!!! 	     (__power_well)++)
ERROR-RECOV: found sync end of #define, line 26
parsing pass2: try again
ERROR-RECOV: found sync end of #define, line 26
parse error 
 = File "./drivers/gpu/drm/i915/display/intel_display_power_well.h", line 26, column 23, charpos = 903
  around = '',
  whole content = 	     (__power_well)--)
badcount: 6
bad: 	     (__power_well)++)
bad: 
bad: #define for_each_power_well_reverse(__dev_priv, __power_well)			\
bad: 	for ((__power_well) = (__dev_priv)->display.power.domains.power_wells +		\
bad: 			      (__dev_priv)->display.power.domains.power_well_count - 1;	\
bad: 	     (__power_well) - (__dev_priv)->display.power.domains.power_wells >= 0;	\
BAD:!!!!! 	     (__power_well)--)
ERROR-RECOV: found sync end of #define, line 28
parsing pass2: try again
ERROR-RECOV: found sync end of #define, line 28
parse error 
 = File "./drivers/gpu/drm/i915/display/intel_display_power.c", line 28, column 2, charpos = 730
  around = 'for_each_if',
  whole content = 		for_each_if(test_bit((__domain), (__power_well)->domains.bits))
badcount: 4
bad: #include "vlv_sideband.h"
bad: 
bad: #define for_each_power_domain_well(__dev_priv, __power_well, __domain)	\
bad: 	for_each_power_well(__dev_priv, __power_well)				\
BAD:!!!!! 		for_each_if(test_bit((__domain), (__power_well)->domains.bits))
ERROR-RECOV: found sync end of #define, line 32
parsing pass2: try again
ERROR-RECOV: found sync end of #define, line 32
parse error 
 = File "./drivers/gpu/drm/i915/display/intel_display_power.c", line 32, column 2, charpos = 944
  around = 'for_each_if',
  whole content = 		for_each_if(test_bit((__domain), (__power_well)->domains.bits))
badcount: 4
bad: 		for_each_if(test_bit((__domain), (__power_well)->domains.bits))
bad: 
bad: #define for_each_power_domain_well_reverse(__dev_priv, __power_well, __domain) \
bad: 	for_each_power_well_reverse(__dev_priv, __power_well)		        \
BAD:!!!!! 		for_each_if(test_bit((__domain), (__power_well)->domains.bits))
dependencies for rule macros_noargs satisfied:
dependencies for rule nested_macros satisfied:
dependencies for rule rule starting on line 42 satisfied:
     (ONCE) USING optional_qualifier builtin isomorphism
dependencies for rule rule starting on line 58 satisfied:
     (ONCE) USING optional_storage builtin isomorphism
Check duplication for 20 files

Re: [cocci] Searching for special function implementations with SmPL

[Julia Lawall]

On Tue, 31 Jan 2023, Luca Coelho wrote:

> On Mon, 2023-01-30 at 12:59 +0200, Luca Coelho wrote:
> > On Mon, 2023-01-30 at 11:47 +0100, Julia Lawall wrote:
> > > It doesn't find the file with the definition.  You may need to give more
> > > paths.
> > >
> > > I have the impression that the result is improved with
> > >
> > > -I drivers/gpu/drm/i915
> > >
> > > Maybe -I drivers/gpu/drm/i915/display is necessary also.  If you add the
> > > argument --relax-include-path then just -I drivers/gpu/drm/i915 may be
> > > sufficient.  With that option, it will just hunt around in and under the
> > > various include paths for a unique file that has the required name.
> >
> > Alright! That _does_ improve things! Now I can see lots of DPLL matches
> > in that file!
>
> These files I'm trying to parse are so complex that I keep bumping into
> other parsing errors.  Here's one of them:
>
> parse error
>  = File "./drivers/gpu/drm/i915/i915_drv.h", line 385, column 1, charpos = 9644
>   around = 'for',
>   whole content =       for ((id__) = 0; \
> badcount: 7
> bad: }
> bad:
> bad: /* Simple iterator over all initialised engines */
> bad: #define for_each_engine(engine__, dev_priv__, id__) \
> BAD:!!!!!       for ((id__) = 0; \
> bad:         (id__) < I915_NUM_ENGINES; \
> bad:         (id__)++) \
> bad:            for_each_if ((engine__) = (dev_priv__)->engine[(id__)])
> ERROR-RECOV: found sync end of #define, line 395
>
>
> I believe the parser is getting confused by an iterator inside an
> iterator's definition... I already tried to add them both with the
> "iterator name" directive, but it didn't help...
>
> Any idea what I can do about this?

If you don't care about finding things in this code, you can just ignore
it.

julia

Re: [cocci] Searching for special function implementations with SmPL

[Luca Coelho]

On Tue, 2023-01-31 at 17:08 +0100, Julia Lawall wrote:
> 
> On Tue, 31 Jan 2023, Luca Coelho wrote:
> 
> > On Mon, 2023-01-30 at 12:59 +0200, Luca Coelho wrote:
> > > On Mon, 2023-01-30 at 11:47 +0100, Julia Lawall wrote:
> > > > It doesn't find the file with the definition.  You may need to give more
> > > > paths.
> > > > 
> > > > I have the impression that the result is improved with
> > > > 
> > > > -I drivers/gpu/drm/i915
> > > > 
> > > > Maybe -I drivers/gpu/drm/i915/display is necessary also.  If you add the
> > > > argument --relax-include-path then just -I drivers/gpu/drm/i915 may be
> > > > sufficient.  With that option, it will just hunt around in and under the
> > > > various include paths for a unique file that has the required name.
> > > 
> > > Alright! That _does_ improve things! Now I can see lots of DPLL matches
> > > in that file!
> > 
> > These files I'm trying to parse are so complex that I keep bumping into
> > other parsing errors.  Here's one of them:
> > 
> > parse error
> >  = File "./drivers/gpu/drm/i915/i915_drv.h", line 385, column 1, charpos = 9644
> >   around = 'for',
> >   whole content =       for ((id__) = 0; \
> > badcount: 7
> > bad: }
> > bad:
> > bad: /* Simple iterator over all initialised engines */
> > bad: #define for_each_engine(engine__, dev_priv__, id__) \
> > BAD:!!!!!       for ((id__) = 0; \
> > bad:         (id__) < I915_NUM_ENGINES; \
> > bad:         (id__)++) \
> > bad:            for_each_if ((engine__) = (dev_priv__)->engine[(id__)])
> > ERROR-RECOV: found sync end of #define, line 395
> > 
> > 
> > I believe the parser is getting confused by an iterator inside an
> > iterator's definition... I already tried to add them both with the
> > "iterator name" directive, but it didn't help...
> > 
> > Any idea what I can do about this?
> 
> If you don't care about finding things in this code, you can just ignore
> it.

I don't, but this seems to be included from intel_display_power.c and
I'm not getting the matches I expect in this C file... Maybe there are
other hints in the debugging output?

--
Cheers,
Luca.

Re: [cocci] Searching for special function implementations with SmPL

[Julia Lawall]

On Tue, 31 Jan 2023, Luca Coelho wrote:

> On Tue, 2023-01-31 at 17:08 +0100, Julia Lawall wrote:
> >
> > On Tue, 31 Jan 2023, Luca Coelho wrote:
> >
> > > On Mon, 2023-01-30 at 12:59 +0200, Luca Coelho wrote:
> > > > On Mon, 2023-01-30 at 11:47 +0100, Julia Lawall wrote:
> > > > > It doesn't find the file with the definition.  You may need to give more
> > > > > paths.
> > > > >
> > > > > I have the impression that the result is improved with
> > > > >
> > > > > -I drivers/gpu/drm/i915
> > > > >
> > > > > Maybe -I drivers/gpu/drm/i915/display is necessary also.  If you add the
> > > > > argument --relax-include-path then just -I drivers/gpu/drm/i915 may be
> > > > > sufficient.  With that option, it will just hunt around in and under the
> > > > > various include paths for a unique file that has the required name.
> > > >
> > > > Alright! That _does_ improve things! Now I can see lots of DPLL matches
> > > > in that file!
> > >
> > > These files I'm trying to parse are so complex that I keep bumping into
> > > other parsing errors.  Here's one of them:
> > >
> > > parse error
> > >  = File "./drivers/gpu/drm/i915/i915_drv.h", line 385, column 1, charpos = 9644
> > >   around = 'for',
> > >   whole content =       for ((id__) = 0; \
> > > badcount: 7
> > > bad: }
> > > bad:
> > > bad: /* Simple iterator over all initialised engines */
> > > bad: #define for_each_engine(engine__, dev_priv__, id__) \
> > > BAD:!!!!!       for ((id__) = 0; \
> > > bad:         (id__) < I915_NUM_ENGINES; \
> > > bad:         (id__)++) \
> > > bad:            for_each_if ((engine__) = (dev_priv__)->engine[(id__)])
> > > ERROR-RECOV: found sync end of #define, line 395
> > >
> > >
> > > I believe the parser is getting confused by an iterator inside an
> > > iterator's definition... I already tried to add them both with the
> > > "iterator name" directive, but it didn't help...
> > >
> > > Any idea what I can do about this?
> >
> > If you don't care about finding things in this code, you can just ignore
> > it.
>
> I don't, but this seems to be included from intel_display_power.c and
> I'm not getting the matches I expect in this C file... Maybe there are
> other hints in the debugging output?

If you know a function that should be matched, then you can check if there
are bad/BAD comments in front of that function.  bad/BAD comments
elsewhere don't matter.

You can also use the --debug option and see if the macro name that you
expect is getting collected.

You can use the --verbose-includes option to see if the file that contains
the definition of the macro of interest is actually found and included.

julia

Re: [cocci] Adding a parameter for special macro calls with SmPL

[Markus Elfring]

> @macros_noargs@
> identifier m;
> expression e =~ "dev_priv";
> @@
> #define m <+...e...+>
>
> @nested_macros@
> identifier macros_noargs.m;
> identifier nm;
> identifier list il;
> @@
> #define nm(il) <+...m...+>
>
> @@
> identifier nested_macros.nm;
> identifier list il;
> expression e;
> @@
> -#define nm(il) e
> +#define nm(dev_priv, il) e
>
> @@
> identifier nested_macros.nm;
> identifier dev_priv, f;
> expression e;
> expression list il;
> @@
> f(...) {
> 	...
> (
> 	struct drm_i915_private *dev_priv = e;
> |
> 	struct drm_i915_private *dev_priv;
> )


I suggest to another look at the isomorphism “decl_init”.
https://gitlab.inria.fr/coccinelle/coccinelle/-/blob/b9603af4eca7f4c771d57a3861855332e9bb1c4c/standard.iso#L465



> 	<+...
> -	nm(il)
> +	nm(dev_priv, il)
> 	...+>
> }
>
>
> The idea is that all the macros that are implicitly using dev_priv,
> will have a new argument where dev_priv is passed.


Your description evolved for the desired transformation considerably.


How do you think about to use the following SmPL script variant?


@macros_noargs@
identifier m;
expression e =~ "dev_priv";
@@
#define m <+...e...+>

@nested_macros@
identifier macros_noargs.m, nm;
identifier list il;
@@
#define nm(il) <+...m...+>

@addition1@
identifier nested_macros.nm;
identifier list il;
expression e;
@@
-#define nm(il) e
+#define nm(dev_priv, il) e

@addition2@
identifier nested_macros.nm, dev_priv, f;
expression list el;
@@
 f(...)
 {
 ...
 struct drm_i915_private *dev_priv;
 <+...
 nm(
+   dev_priv,
    el)
 ...+>
 }


> After mangling a lot with the rules, I can see that this now works,


This understanding is nice.



> but only if I select the vlv_dsi.c file alone, like this:


This observation will probably need further explanations.



> Of course, I can work around this by using find and running spatch
> individually in every file... But not ideal.


The Coccinelle software should take care of corresponding source file searches already.

Regards,
Markus

Re: [cocci] Adding a parameter for special macro calls with SmPL

[Luca Coelho]

On Sun, 2023-01-29 at 19:01 +0100, Markus Elfring wrote:
> > @macros_noargs@
> > identifier m;
> > expression e =~ "dev_priv";
> > @@
> > #define m <+...e...+>
> > 
> > @nested_macros@
> > identifier macros_noargs.m;
> > identifier nm;
> > identifier list il;
> > @@
> > #define nm(il) <+...m...+>
> > 
> > @@
> > identifier nested_macros.nm;
> > identifier list il;
> > expression e;
> > @@
> > -#define nm(il) e
> > +#define nm(dev_priv, il) e
> > 
> > @@
> > identifier nested_macros.nm;
> > identifier dev_priv, f;
> > expression e;
> > expression list il;
> > @@
> > f(...) {
> > 	...
> > (
> > 	struct drm_i915_private *dev_priv = e;
> > > 
> > 	struct drm_i915_private *dev_priv;
> > )
> 
> 
> I suggest to another look at the isomorphism “decl_init”.
> https://gitlab.inria.fr/coccinelle/coccinelle/-
> /blob/b9603af4eca7f4c771d57a3861855332e9bb1c4c/standard.iso#L465

Thanks, I took a look, the optional initialization is better, indeed.

> 
> 
> 
> > 	<+...
> > -	nm(il)
> > +	nm(dev_priv, il)
> > 	...+>
> > }
> > 
> > 
> > The idea is that all the macros that are implicitly using dev_priv,
> > will have a new argument where dev_priv is passed.
> 
> 
> Your description evolved for the desired transformation considerably.

Yes, sorry, I wanted to keep it as simple as possible, but leaving most
of the story out was indeed a problem, because it was lacking context.


> How do you think about to use the following SmPL script variant?
> 
> 
> @macros_noargs@
> identifier m;
> expression e =~ "dev_priv";
> @@
> #define m <+...e...+>
> 
> @nested_macros@
> identifier macros_noargs.m, nm;
> identifier list il;
> @@
> #define nm(il) <+...m...+>
> 
> @addition1@
> identifier nested_macros.nm;
> identifier list il;
> expression e;
> @@
> -#define nm(il) e
> +#define nm(dev_priv, il) e
> 
> @addition2@
> identifier nested_macros.nm, dev_priv, f;
> expression list el;
> @@
>  f(...)
>  {
>  ...
>  struct drm_i915_private *dev_priv;
>  <+...
>  nm(
> +   dev_priv,
>     el)
>  ...+>
>  }

This is nice, I'll change it.


> > After mangling a lot with the rules, I can see that this now works,
> 
> 
> This understanding is nice.
> 
> 
> 
> > but only if I select the vlv_dsi.c file alone, like this:
> 
> 
> This observation will probably need further explanations.
> 
> 
> 
> > Of course, I can work around this by using find and running spatch
> > individually in every file... But not ideal.
> 
> 
> The Coccinelle software should take care of corresponding source file
> searches already.

It should, but it doesn't seem to be working properly.

--
Cheers,
Luca.

Re: [cocci] Searching for special function implementations with SmPL

[Markus Elfring]

> @@
> identifier nested_macros.nm;
> identifier dev_priv, f;
> expression e;
> @@
> f(...) {
> 	...
> -	struct drm_i915_private *dev_priv = e;
> +	struct drm_i915_private *i915 = e;
>
> 	<+...
> 	nm(...)
> 	...+>
> }


You would like to rename a local variable.
How do you think about to check if the chosen variable name will actually be used?



> +++ b/intel_display.c
> @@ -3943,7 +3943,7 @@ static bool bxt_get_dsi_transcoder_state
>  					 struct intel_display_power_domain_set *power_domain_set)
>  {
>  	struct drm_device *dev = crtc->base.dev;
> -	struct drm_i915_private *dev_priv = to_i915(dev);
> +	struct drm_i915_private *i915 = to_i915(dev);
>  	enum transcoder cpu_transcoder;
>  	enum port port;
>  	u32 tmp;

Which function-like macros should be found in such an implementation?
https://elixir.bootlin.com/linux/v6.2-rc5/source/drivers/gpu/drm/i915/display/intel_display.c#L3991



> Many other files are handled, but there are no matches, though I
> believe there should be.

Would you like to split the SmPL search patterns for another test
so that your expectations can be clarified better?

Regards,
Markus

Re: [cocci] Searching for special function implementations with SmPL

[Luca Coelho]

On Sat, 2023-01-28 at 14:43 +0100, Markus Elfring wrote:
> > @@
> > identifier nested_macros.nm;
> > identifier dev_priv, f;
> > expression e;
> > @@
> > f(...) {
> > 	...
> > -	struct drm_i915_private *dev_priv = e;
> > +	struct drm_i915_private *i915 = e;
> > 
> > 	<+...
> > 	nm(...)
> > 	...+>
> > }
> 
> 
> You would like to rename a local variable.
> How do you think about to check if the chosen variable name will
> actually be used?
> 
> 
> 
> > +++ b/intel_display.c
> > @@ -3943,7 +3943,7 @@ static bool bxt_get_dsi_transcoder_state
> >  					 struct
> > intel_display_power_domain_set *power_domain_set)
> >  {
> >  	struct drm_device *dev = crtc->base.dev;
> > -	struct drm_i915_private *dev_priv = to_i915(dev);
> > +	struct drm_i915_private *i915 = to_i915(dev);
> >  	enum transcoder cpu_transcoder;
> >  	enum port port;
> >  	u32 tmp;
> 
> Which function-like macros should be found in such an implementation?
> https://elixir.bootlin.com/linux/v6.2-
> rc5/source/drivers/gpu/drm/i915/display/intel_display.c#L3991
> 
> 
> 
> > Many other files are handled, but there are no matches, though I
> > believe there should be.
> 
> Would you like to split the SmPL search patterns for another test
> so that your expectations can be clarified better?

Hi Markus,

Thanks for all the input.  I explained what I want to do (hopefully) a
bit more clearly in reply to Julia's latest email.

--
Cheers,
Luca.