Merge tag 'drm-misc-fixes-2022-04-22' of git://anongit.freedesktop.org/drm/drm-misc into drm-fixes

Two fixes for the raspberrypi panel initialisation, one fix for a logic inversion in radeon, a build and pm refcounting fix for vc4, two reverts for drm_of_get_bridge that caused a number of regression and a locking regression for amdgpu. Signed-off-by: Dave Airlie <airlied@redhat.com>

Dave Airlie committed 4 years ago

Commit c18a2a22 parents 70da382 94f4c4912 files · +94 −358Browse files

Unified · Split

12 files

drivers/gpu/drm/amd/amdgpu/amdgpu_cs.c +15 −6
drivers/gpu/drm/amd/amdgpu/amdgpu_ctx.c +2 −0
drivers/gpu/drm/amd/amdgpu/amdgpu_ctx.h +1 −0
drivers/gpu/drm/drm_of.c +33 −51
drivers/gpu/drm/panel/panel-raspberrypi-touchscreen.c +10 −3
drivers/gpu/drm/radeon/radeon_sync.c +1 −1
drivers/gpu/drm/vc4/Kconfig +3 −0
drivers/gpu/drm/vc4/vc4_dsi.c +1 −1
drivers/gpu/drm/vmwgfx/vmwgfx_bo.c +20 −23
drivers/gpu/drm/vmwgfx/vmwgfx_drv.c +2 −6
drivers/gpu/drm/vmwgfx/vmwgfx_surface.c +6 −1
include/linux/dma-buf-map.h +0 −266

drivers/gpu/drm/amd/amdgpu/amdgpu_cs.c+15−6

 		goto free_chunk;
 	}
+	mutex_lock(&p->ctx->lock);
 	/* skip guilty context job */
 	if (atomic_read(&p->ctx->guilty) == 1) {
 		ret = -ECANCELED;
 	dma_fence_put(parser->fence);
 	if (parser->ctx) {
+		mutex_unlock(&parser->ctx->lock);
 		amdgpu_ctx_put(parser->ctx);
 	}
 	if (parser->bo_list)
 {
 	int i, r;
+	/* TODO: Investigate why we still need the context lock */
+	mutex_unlock(&p->ctx->lock);
 	for (i = 0; i < p->nchunks; ++i) {
 		struct amdgpu_cs_chunk *chunk;
 		case AMDGPU_CHUNK_ID_SCHEDULED_DEPENDENCIES:
 			r = amdgpu_cs_process_fence_dep(p, chunk);
 			if (r)
-				return r;
+				goto out;
 			break;
 		case AMDGPU_CHUNK_ID_SYNCOBJ_IN:
 			r = amdgpu_cs_process_syncobj_in_dep(p, chunk);
 			if (r)
-				return r;
+				goto out;
 			break;
 		case AMDGPU_CHUNK_ID_SYNCOBJ_OUT:
 			r = amdgpu_cs_process_syncobj_out_dep(p, chunk);
 			if (r)
-				return r;
+				goto out;
 			break;
 		case AMDGPU_CHUNK_ID_SYNCOBJ_TIMELINE_WAIT:
 			r = amdgpu_cs_process_syncobj_timeline_in_dep(p, chunk);
 			if (r)
-				return r;
+				goto out;
 			break;
 		case AMDGPU_CHUNK_ID_SYNCOBJ_TIMELINE_SIGNAL:
 			r = amdgpu_cs_process_syncobj_timeline_out_dep(p, chunk);
 			if (r)
-				return r;
+				goto out;
 			break;
 		}
 	}
-	return 0;
+out:
+	mutex_lock(&p->ctx->lock);
+	return r;
 }
 static void amdgpu_cs_post_dependencies(struct amdgpu_cs_parser *p)
 		goto out;
 	r = amdgpu_cs_submit(&parser, cs);
 out:
 	amdgpu_cs_parser_fini(&parser, r, reserved_buffers);

drivers/gpu/drm/amd/amdgpu/amdgpu_ctx.c+2−0

 	kref_init(&ctx->refcount);
 	spin_lock_init(&ctx->ring_lock);
+	mutex_init(&ctx->lock);
 	ctx->reset_counter = atomic_read(&adev->gpu_reset_counter);
 	ctx->reset_counter_query = ctx->reset_counter;
 		drm_dev_exit(idx);
 	}
+	mutex_destroy(&ctx->lock);
 	kfree(ctx);
 }

drivers/gpu/drm/amd/amdgpu/amdgpu_ctx.h+1−0

@@ -49,6 +49,7 @@ struct amdgpu_ctx { · 48 unmodified lines
49	bool preamble_presented;	49	bool preamble_presented;
50	int32_t init_priority;	50	int32_t init_priority;
51	int32_t override_priority;	51	int32_t override_priority;
		52	struct mutex lock;
52	atomic_t guilty;	53	atomic_t guilty;
53	unsigned long ras_counter_ce;	54	unsigned long ras_counter_ce;
54	unsigned long ras_counter_ue;	55	unsigned long ras_counter_ue;

drivers/gpu/drm/drm_of.c+33−51

 }
 EXPORT_SYMBOL_GPL(drm_of_encoder_active_endpoint);
-static int find_panel_or_bridge(struct device_node *node,
-				struct drm_panel **panel,
-				struct drm_bridge **bridge)
-{
-	if (panel) {
-		*panel = of_drm_find_panel(node);
-		if (!IS_ERR(*panel))
-			return 0;
-		/* Clear the panel pointer in case of error. */
-		*panel = NULL;
-	}
-	/* No panel found yet, check for a bridge next. */
-	if (bridge) {
-		*bridge = of_drm_find_bridge(node);
-		if (*bridge)
-			return 0;
-	}
-	return -EPROBE_DEFER;
-}
 /**
  * drm_of_find_panel_or_bridge - return connected panel or bridge device
  * @np: device tree node containing encoder output ports
 				struct drm_panel **panel,
 				struct drm_bridge **bridge)
 {
-	struct device_node *node;
+	int ret = -EPROBE_DEFER;
-	int ret;
+	struct device_node *remote;
 	if (!panel && !bridge)
 		return -EINVAL;
 	if (panel)
 		*panel = NULL;
-	if (bridge)
-		*bridge = NULL;
-	/* Check for a graph on the device node first. */
-	if (of_graph_is_present(np)) {
-		node = of_graph_get_remote_node(np, port, endpoint);
-		if (node) {
-			ret = find_panel_or_bridge(node, panel, bridge);
-			of_node_put(node);
-			if (!ret)
-				return 0;
-		}
-	}
-	/* Otherwise check for any child node other than port/ports. */
+	/*
-	for_each_available_child_of_node(np, node) {
+	 * of_graph_get_remote_node() produces a noisy error message if port
-		if (of_node_name_eq(node, "port") ||
+	 * node isn't found and the absence of the port is a legit case here,
-		    of_node_name_eq(node, "ports"))
+	 * so at first we silently check whether graph presents in the
-			continue;
+	 * device-tree node.
+	 */
+	if (!of_graph_is_present(np))
+		return -ENODEV;
-		ret = find_panel_or_bridge(node, panel, bridge);
+	remote = of_graph_get_remote_node(np, port, endpoint);
-		of_node_put(node);
+	if (!remote)
+		return -ENODEV;
+	if (panel) {
+		*panel = of_drm_find_panel(remote);
+		if (!IS_ERR(*panel))
+			ret = 0;
+		else
+			*panel = NULL;
+	}
+	/* No panel found yet, check for a bridge next. */
+	if (bridge) {
+		if (ret) {
+			*bridge = of_drm_find_bridge(remote);
+			if (*bridge)
+				ret = 0;
+		} else {
+			*bridge = NULL;
+		}
-		/* Stop at the first found occurrence. */
-		if (!ret)
-			return 0;
 	}
-	return -EPROBE_DEFER;
+	of_node_put(remote);
+	return ret;
 }
 EXPORT_SYMBOL_GPL(drm_of_find_panel_or_bridge);

drivers/gpu/drm/panel/panel-raspberrypi-touchscreen.c+10−3

 	ret = i2c_smbus_write_byte_data(ts->i2c, reg, val);
 	if (ret)
-		dev_err(&ts->dsi->dev, "I2C write failed: %d\n", ret);
+		dev_err(&ts->i2c->dev, "I2C write failed: %d\n", ret);
 }
 static int rpi_touchscreen_write(struct rpi_touchscreen *ts, u16 reg, u32 val)
 	return 0;
 }
-static int rpi_touchscreen_enable(struct drm_panel *panel)
+static int rpi_touchscreen_prepare(struct drm_panel *panel)
 {
 	struct rpi_touchscreen *ts = panel_to_ts(panel);
 	int i;
 	rpi_touchscreen_write(ts, DSI_STARTDSI, 0x01);
 	msleep(100);
+	return 0;
+}
+static int rpi_touchscreen_enable(struct drm_panel *panel)
+{
+	struct rpi_touchscreen *ts = panel_to_ts(panel);
 	/* Turn on the backlight. */
 	rpi_touchscreen_i2c_write(ts, REG_PWM, 255);
 static const struct drm_panel_funcs rpi_touchscreen_funcs = {
 	.disable = rpi_touchscreen_disable,
 	.unprepare = rpi_touchscreen_noop,
-	.prepare = rpi_touchscreen_noop,
+	.prepare = rpi_touchscreen_prepare,
 	.enable = rpi_touchscreen_enable,
 	.get_modes = rpi_touchscreen_get_modes,
 };

drivers/gpu/drm/radeon/radeon_sync.c+1−1

@@ -96,7 +96,7 @@ int radeon_sync_resv(struct radeon_device *rdev, · 95 unmodified lines
96	struct dma_fence *f;	96	struct dma_fence *f;
97	int r = 0;	97	int r = 0;
98		98
99	dma_resv_for_each_fence(&cursor, resv, shared, f) {	99	dma_resv_for_each_fence(&cursor, resv, !shared, f) {
100	fence = to_radeon_fence(f);	100	fence = to_radeon_fence(f);
101	if (fence && fence->rdev == rdev)	101	if (fence && fence->rdev == rdev)
102	radeon_sync_fence(sync, fence);	102	radeon_sync_fence(sync, fence);

drivers/gpu/drm/vc4/Kconfig+3−0

 config DRM_VC4
 	tristate "Broadcom VC4 Graphics"
 	depends on ARCH_BCM || ARCH_BCM2835 || COMPILE_TEST
+	# Make sure not 'y' when RASPBERRYPI_FIRMWARE is 'm'. This can only
+	# happen when COMPILE_TEST=y, hence the added !RASPBERRYPI_FIRMWARE.
+	depends on RASPBERRYPI_FIRMWARE || (COMPILE_TEST && !RASPBERRYPI_FIRMWARE)
 	depends on DRM
 	depends on SND && SND_SOC
 	depends on COMMON_CLK

drivers/gpu/drm/vc4/vc4_dsi.c+1−1

@@ -846,7 +846,7 @@ static void vc4_dsi_encoder_enable(struct drm_encoder *encoder) · 845 unmodified lines
846	unsigned long phy_clock;	846	unsigned long phy_clock;
847	int ret;	847	int ret;
848		848
849	ret = pm_runtime_get_sync(dev);	849	ret = pm_runtime_resume_and_get(dev);
850	if (ret) {	850	if (ret) {
851	DRM_ERROR("Failed to runtime PM enable on DSI%d\n", dsi->variant->port);	851	DRM_ERROR("Failed to runtime PM enable on DSI%d\n", dsi->variant->port);
852	return;	852	return;

drivers/gpu/drm/vmwgfx/vmwgfx_bo.c+20−23

 	return container_of(bo, struct vmw_buffer_object, base);
 }
+/**
+ * bo_is_vmw - check if the buffer object is a &vmw_buffer_object
+ * @bo: ttm buffer object to be checked
+ *
+ * Uses destroy function associated with the object to determine if this is
+ * a &vmw_buffer_object.
+ *
+ * Returns:
+ * true if the object is of &vmw_buffer_object type, false if not.
+ */
+static bool bo_is_vmw(struct ttm_buffer_object *bo)
+{
+	return bo->destroy == &vmw_bo_bo_free ||
+	       bo->destroy == &vmw_gem_destroy;
+}
 /**
  * vmw_bo_pin_in_placement - Validate a buffer to placement.
 		ret = vmw_user_bo_synccpu_grab(vbo, arg->flags);
 		vmw_bo_unreference(&vbo);
-		if (unlikely(ret != 0 && ret != -ERESTARTSYS &&
+		if (unlikely(ret != 0)) {
-			     ret != -EBUSY)) {
+			if (ret == -ERESTARTSYS || ret == -EBUSY)
+				return -EBUSY;
 			DRM_ERROR("Failed synccpu grab on handle 0x%08x.\n",
 				  (unsigned int) arg->handle);
 			return ret;
 void vmw_bo_swap_notify(struct ttm_buffer_object *bo)
 {
 	/* Is @bo embedded in a struct vmw_buffer_object? */
-	if (vmw_bo_is_vmw_bo(bo))
+	if (!bo_is_vmw(bo))
 		return;
 	/* Kill any cached kernel maps before swapout */
 	struct vmw_buffer_object *vbo;
 	/* Make sure @bo is embedded in a struct vmw_buffer_object? */
-	if (vmw_bo_is_vmw_bo(bo))
+	if (!bo_is_vmw(bo))
 		return;
 	vbo = container_of(bo, struct vmw_buffer_object, base);
 	if (mem->mem_type != VMW_PL_MOB && bo->resource->mem_type == VMW_PL_MOB)
 		vmw_resource_unbind_list(vbo);
 }
-/**
- * vmw_bo_is_vmw_bo - check if the buffer object is a &vmw_buffer_object
- * @bo: buffer object to be checked
- *
- * Uses destroy function associated with the object to determine if this is
- * a &vmw_buffer_object.
- *
- * Returns:
- * true if the object is of &vmw_buffer_object type, false if not.
- */
-bool vmw_bo_is_vmw_bo(struct ttm_buffer_object *bo)
-{
-	if (bo->destroy == &vmw_bo_bo_free ||
-	    bo->destroy == &vmw_gem_destroy)
-		return true;
-	return false;
-}

drivers/gpu/drm/vmwgfx/vmwgfx_drv.c+2−6

 		goto out_no_fman;
 	}
-	drm_vma_offset_manager_init(&dev_priv->vma_manager,
-				    DRM_FILE_PAGE_OFFSET_START,
-				    DRM_FILE_PAGE_OFFSET_SIZE);
 	ret = ttm_device_init(&dev_priv->bdev, &vmw_bo_driver,
 			      dev_priv->drm.dev,
 			      dev_priv->drm.anon_inode->i_mapping,
-			      &dev_priv->vma_manager,
+			      dev_priv->drm.vma_offset_manager,
 			      dev_priv->map_mode == vmw_dma_alloc_coherent,
 			      false);
 	if (unlikely(ret != 0)) {
 	vmw_devcaps_destroy(dev_priv);
 	vmw_vram_manager_fini(dev_priv);
 	ttm_device_fini(&dev_priv->bdev);
-	drm_vma_offset_manager_destroy(&dev_priv->vma_manager);
 	vmw_release_device_late(dev_priv);
 	vmw_fence_manager_takedown(dev_priv->fman);
 	if (dev_priv->capabilities & SVGA_CAP_IRQMASK)
 	struct vmw_private *dev_priv = vmw_priv(file_priv->minor->dev);
 	return drm_get_unmapped_area(file, uaddr, len, pgoff, flags,
-				     &dev_priv->vma_manager);
+				     dev_priv->drm.vma_offset_manager);
 }
 static int vmwgfx_pm_notifier(struct notifier_block *nb, unsigned long val,

drivers/gpu/drm/vmwgfx/vmwgfx_surface.c+6−1

 	    container_of(base, struct vmw_user_surface, prime.base);
 	struct vmw_resource *res = &user_srf->srf.res;
+	if (base->shareable && res && res->backup)
+		drm_gem_object_put(&res->backup->base.base);
 	*p_base = NULL;
 	vmw_resource_unreference(&res);
 }
 			goto out_unlock;
 		}
 		vmw_bo_reference(res->backup);
+		drm_gem_object_get(&res->backup->base.base);
 	}
 	tmp = vmw_resource_reference(&srf->res);
 							&res->backup);
 		if (ret == 0)
 			vmw_bo_reference(res->backup);
 	}
 	if (unlikely(ret != 0)) {
 			drm_vma_node_offset_addr(&res->backup->base.base.vma_node);
 		rep->buffer_size = res->backup->base.base.size;
 		rep->buffer_handle = backup_handle;
+		if (user_srf->prime.base.shareable)
+			drm_gem_object_get(&res->backup->base.base);
 	} else {
 		rep->buffer_map_handle = 0;
 		rep->buffer_size = 0;

include/linux/dma-buf-map.h+0−266

@@ -1,266 +0,0 @@
1	/* SPDX-License-Identifier: GPL-2.0-only */
2	/*
3	* Pointer to dma-buf-mapped memory, plus helpers.
4	*/
5
6	#ifndef __DMA_BUF_MAP_H__
7	#define __DMA_BUF_MAP_H__
8
9	#include <linux/io.h>
10	#include <linux/string.h>
11
12	/**
13	* DOC: overview
14	*
15	* Calling dma-buf's vmap operation returns a pointer to the buffer's memory.
16	* Depending on the location of the buffer, users may have to access it with
17	* I/O operations or memory load/store operations. For example, copying to
18	* system memory could be done with memcpy(), copying to I/O memory would be
19	* done with memcpy_toio().
20	*
21	* .. code-block:: c
22	*
23	* void *vaddr = ...; // pointer to system memory
24	* memcpy(vaddr, src, len);
25	*
26	* void *vaddr_iomem = ...; // pointer to I/O memory
27	* memcpy_toio(vaddr, _iomem, src, len);
28	*
29	* When using dma-buf's vmap operation, the returned pointer is encoded as
30	* :c:type:`struct dma_buf_map <dma_buf_map>`.
31	* :c:type:`struct dma_buf_map <dma_buf_map>` stores the buffer's address in
32	* system or I/O memory and a flag that signals the required method of
33	* accessing the buffer. Use the returned instance and the helper functions
34	* to access the buffer's memory in the correct way.
35	*
36	* The type :c:type:`struct dma_buf_map <dma_buf_map>` and its helpers are
37	* actually independent from the dma-buf infrastructure. When sharing buffers
38	* among devices, drivers have to know the location of the memory to access
39	* the buffers in a safe way. :c:type:`struct dma_buf_map <dma_buf_map>`
40	* solves this problem for dma-buf and its users. If other drivers or
41	* sub-systems require similar functionality, the type could be generalized
42	* and moved to a more prominent header file.
43	*
44	* Open-coding access to :c:type:`struct dma_buf_map <dma_buf_map>` is
45	* considered bad style. Rather then accessing its fields directly, use one
46	* of the provided helper functions, or implement your own. For example,
47	* instances of :c:type:`struct dma_buf_map <dma_buf_map>` can be initialized
48	* statically with DMA_BUF_MAP_INIT_VADDR(), or at runtime with
49	* dma_buf_map_set_vaddr(). These helpers will set an address in system memory.
50	*
51	* .. code-block:: c
52	*
53	* struct dma_buf_map map = DMA_BUF_MAP_INIT_VADDR(0xdeadbeaf);
54	*
55	* dma_buf_map_set_vaddr(&map, 0xdeadbeaf);
56	*
57	* To set an address in I/O memory, use dma_buf_map_set_vaddr_iomem().
58	*
59	* .. code-block:: c
60	*
61	* dma_buf_map_set_vaddr_iomem(&map, 0xdeadbeaf);
62	*
63	* Instances of struct dma_buf_map do not have to be cleaned up, but
64	* can be cleared to NULL with dma_buf_map_clear(). Cleared mappings
65	* always refer to system memory.
66	*
67	* .. code-block:: c
68	*
69	* dma_buf_map_clear(&map);
70	*
71	* Test if a mapping is valid with either dma_buf_map_is_set() or
72	* dma_buf_map_is_null().
73	*
74	* .. code-block:: c
75	*
76	* if (dma_buf_map_is_set(&map) != dma_buf_map_is_null(&map))
77	* // always true
78	*
79	* Instances of :c:type:`struct dma_buf_map <dma_buf_map>` can be compared
80	* for equality with dma_buf_map_is_equal(). Mappings the point to different
81	* memory spaces, system or I/O, are never equal. That's even true if both
82	* spaces are located in the same address space, both mappings contain the
83	* same address value, or both mappings refer to NULL.
84	*
85	* .. code-block:: c
86	*
87	* struct dma_buf_map sys_map; // refers to system memory
88	* struct dma_buf_map io_map; // refers to I/O memory
89	*
90	* if (dma_buf_map_is_equal(&sys_map, &io_map))
91	* // always false
92	*
93	* A set up instance of struct dma_buf_map can be used to access or manipulate
94	* the buffer memory. Depending on the location of the memory, the provided
95	* helpers will pick the correct operations. Data can be copied into the memory
96	* with dma_buf_map_memcpy_to(). The address can be manipulated with
97	* dma_buf_map_incr().
98	*
99	* .. code-block:: c
100	*
101	* const void *src = ...; // source buffer
102	* size_t len = ...; // length of src
103	*
104	* dma_buf_map_memcpy_to(&map, src, len);
105	* dma_buf_map_incr(&map, len); // go to first byte after the memcpy
106	*/
107
108	/**
109	* struct dma_buf_map - Pointer to vmap'ed dma-buf memory.
110	* @vaddr_iomem: The buffer's address if in I/O memory
111	* @vaddr: The buffer's address if in system memory
112	* @is_iomem: True if the dma-buf memory is located in I/O
113	* memory, or false otherwise.
114	*/
115	struct dma_buf_map {
116	union {
117	void __iomem *vaddr_iomem;
118	void *vaddr;
119	};
120	bool is_iomem;
121	};
122
123	/**
124	* DMA_BUF_MAP_INIT_VADDR - Initializes struct dma_buf_map to an address in system memory
125	* @vaddr_: A system-memory address
126	*/
127	#define DMA_BUF_MAP_INIT_VADDR(vaddr_) \
128	{ \
129	.vaddr = (vaddr_), \
130	.is_iomem = false, \
131	}
132
133	/**
134	* dma_buf_map_set_vaddr - Sets a dma-buf mapping structure to an address in system memory
135	* @map: The dma-buf mapping structure
136	* @vaddr: A system-memory address
137	*
138	* Sets the address and clears the I/O-memory flag.
139	*/
140	static inline void dma_buf_map_set_vaddr(struct dma_buf_map map, void vaddr)
141	{
142	map->vaddr = vaddr;
143	map->is_iomem = false;
144	}
145
146	/**
147	* dma_buf_map_set_vaddr_iomem - Sets a dma-buf mapping structure to an address in I/O memory
148	* @map: The dma-buf mapping structure
149	* @vaddr_iomem: An I/O-memory address
150	*
151	* Sets the address and the I/O-memory flag.
152	*/
153	static inline void dma_buf_map_set_vaddr_iomem(struct dma_buf_map *map,
154	void __iomem *vaddr_iomem)
155	{
156	map->vaddr_iomem = vaddr_iomem;
157	map->is_iomem = true;
158	}
159
160	/**
161	* dma_buf_map_is_equal - Compares two dma-buf mapping structures for equality
162	* @lhs: The dma-buf mapping structure
163	* @rhs: A dma-buf mapping structure to compare with
164	*
165	* Two dma-buf mapping structures are equal if they both refer to the same type of memory
166	* and to the same address within that memory.
167	*
168	* Returns:
169	* True is both structures are equal, or false otherwise.
170	*/
171	static inline bool dma_buf_map_is_equal(const struct dma_buf_map *lhs,
172	const struct dma_buf_map *rhs)
173	{
174	if (lhs->is_iomem != rhs->is_iomem)
175	return false;
176	else if (lhs->is_iomem)
177	return lhs->vaddr_iomem == rhs->vaddr_iomem;
178	else
179	return lhs->vaddr == rhs->vaddr;
180	}
181
182	/**
183	* dma_buf_map_is_null - Tests for a dma-buf mapping to be NULL
184	* @map: The dma-buf mapping structure
185	*
186	* Depending on the state of struct dma_buf_map.is_iomem, tests if the
187	* mapping is NULL.
188	*
189	* Returns:
190	* True if the mapping is NULL, or false otherwise.
191	*/
192	static inline bool dma_buf_map_is_null(const struct dma_buf_map *map)
193	{
194	if (map->is_iomem)
195	return !map->vaddr_iomem;
196	return !map->vaddr;
197	}
198
199	/**
200	* dma_buf_map_is_set - Tests is the dma-buf mapping has been set
201	* @map: The dma-buf mapping structure
202	*
203	* Depending on the state of struct dma_buf_map.is_iomem, tests if the
204	* mapping has been set.
205	*
206	* Returns:
207	* True if the mapping is been set, or false otherwise.
208	*/
209	static inline bool dma_buf_map_is_set(const struct dma_buf_map *map)
210	{
211	return !dma_buf_map_is_null(map);
212	}
213
214	/**
215	* dma_buf_map_clear - Clears a dma-buf mapping structure
216	* @map: The dma-buf mapping structure
217	*
218	* Clears all fields to zero; including struct dma_buf_map.is_iomem. So
219	* mapping structures that were set to point to I/O memory are reset for
220	* system memory. Pointers are cleared to NULL. This is the default.
221	*/
222	static inline void dma_buf_map_clear(struct dma_buf_map *map)
223	{
224	if (map->is_iomem) {
225	map->vaddr_iomem = NULL;
226	map->is_iomem = false;
227	} else {
228	map->vaddr = NULL;
229	}
230	}
231
232	/**
233	* dma_buf_map_memcpy_to - Memcpy into dma-buf mapping
234	* @dst: The dma-buf mapping structure
235	* @src: The source buffer
236	* @len: The number of byte in src
237	*
238	* Copies data into a dma-buf mapping. The source buffer is in system
239	* memory. Depending on the buffer's location, the helper picks the correct
240	* method of accessing the memory.
241	*/
242	static inline void dma_buf_map_memcpy_to(struct dma_buf_map dst, const void src, size_t len)
243	{
244	if (dst->is_iomem)
245	memcpy_toio(dst->vaddr_iomem, src, len);
246	else
247	memcpy(dst->vaddr, src, len);
248	}
249
250	/**
251	* dma_buf_map_incr - Increments the address stored in a dma-buf mapping
252	* @map: The dma-buf mapping structure
253	* @incr: The number of bytes to increment
254	*
255	* Increments the address stored in a dma-buf mapping. Depending on the
256	* buffer's location, the correct value will be updated.
257	*/
258	static inline void dma_buf_map_incr(struct dma_buf_map *map, size_t incr)
259	{
260	if (map->is_iomem)
261	map->vaddr_iomem += incr;
262	else
263	map->vaddr += incr;
264	}
265
266	#endif /* __DMA_BUF_MAP_H__ */