1/*
2 * Copyright (C) 2010-2011 Chia-I Wu <olvaffe@gmail.com>
3 * Copyright (C) 2010-2011 LunarG Inc.
4 *
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the "Software"),
7 * to deal in the Software without restriction, including without limitation
8 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 * and/or sell copies of the Software, and to permit persons to whom the
10 * Software is furnished to do so, subject to the following conditions:
11 *
12 * The above copyright notice and this permission notice shall be included
13 * in all copies or substantial portions of the Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21 * DEALINGS IN THE SOFTWARE.
22 */
23
24#define LOG_TAG "GRALLOC-DRM"
25
26#include <cutils/log.h>
27#include <cutils/atomic.h>
28#include <cutils/properties.h>
29#include <stdlib.h>
30#include <errno.h>
31#include <sys/types.h>
32#include <sys/stat.h>
33#include <fcntl.h>
34
35#include "gralloc_drm.h"
36#include "gralloc_drm_priv.h"
37
38#define unlikely(x) __builtin_expect(!!(x), 0)
39
40static int32_t gralloc_drm_pid = 0;
41
42/*
43 * Return the pid of the process.
44 */
45static int gralloc_drm_get_pid(void)
46{
47	if (unlikely(!gralloc_drm_pid))
48		android_atomic_write((int32_t) getpid(), &gralloc_drm_pid);
49
50	return gralloc_drm_pid;
51}
52
53/*
54 * Create the driver for a DRM fd.
55 */
56static struct gralloc_drm_drv_t *
57init_drv_from_fd(int fd)
58{
59	struct gralloc_drm_drv_t *drv = NULL;
60	drmVersionPtr version;
61
62	/* get the kernel module name */
63	version = drmGetVersion(fd);
64	if (!version) {
65		ALOGE("invalid DRM fd");
66		return NULL;
67	}
68
69	if (version->name) {
70#ifdef ENABLE_PIPE
71		drv = gralloc_drm_drv_create_for_pipe(fd, version->name);
72#endif
73
74#ifdef ENABLE_INTEL
75		if (!drv && !strcmp(version->name, "i915"))
76			drv = gralloc_drm_drv_create_for_intel(fd);
77#endif
78#ifdef ENABLE_RADEON
79		if (!drv && !strcmp(version->name, "radeon"))
80			drv = gralloc_drm_drv_create_for_radeon(fd);
81#endif
82#ifdef ENABLE_ROCKCHIP
83		if (!drv && !strcmp(version->name, "rockchip"))
84			drv = gralloc_drm_drv_create_for_rockchip(fd);
85#endif
86#ifdef ENABLE_NOUVEAU
87		if (!drv && !strcmp(version->name, "nouveau"))
88			drv = gralloc_drm_drv_create_for_nouveau(fd);
89#endif
90	}
91
92	if (!drv) {
93		ALOGE("unsupported driver: %s", (version->name) ?
94				version->name : "NULL");
95	}
96
97	drmFreeVersion(version);
98
99	return drv;
100}
101
102/*
103 * Create a DRM device object.
104 */
105struct gralloc_drm_t *gralloc_drm_create(void)
106{
107	char path[PROPERTY_VALUE_MAX];
108	struct gralloc_drm_t *drm;
109	int err;
110
111	drm = new gralloc_drm_t;
112	if (!drm)
113		return NULL;
114
115	property_get("gralloc.drm.device", path, "/dev/dri/renderD128");
116	drm->fd = open(path, O_RDWR);
117	if (drm->fd < 0) {
118		ALOGE("failed to open %s", path);
119		return NULL;
120	}
121
122	drm->drv = init_drv_from_fd(drm->fd);
123	if (!drm->drv) {
124		close(drm->fd);
125		delete drm;
126		return NULL;
127	}
128
129	return drm;
130}
131
132/*
133 * Destroy a DRM device object.
134 */
135void gralloc_drm_destroy(struct gralloc_drm_t *drm)
136{
137	if (drm->drv)
138		drm->drv->destroy(drm->drv);
139	close(drm->fd);
140	delete drm;
141}
142
143/*
144 * Get the file descriptor of a DRM device object.
145 */
146int gralloc_drm_get_fd(struct gralloc_drm_t *drm)
147{
148	return drm->fd;
149}
150
151/*
152 * Validate a buffer handle and return the associated bo.
153 */
154static struct gralloc_drm_bo_t *validate_handle(buffer_handle_t _handle,
155		struct gralloc_drm_t *drm)
156{
157	struct gralloc_drm_handle_t *handle = gralloc_drm_handle(_handle);
158
159	if (!handle)
160		return NULL;
161
162	/* the buffer handle is passed to a new process */
163	ALOGE("data_owner=%d gralloc_pid=%d data=%p\n", handle->data_owner, gralloc_drm_get_pid(), handle->data);
164	if (unlikely(handle->data_owner != gralloc_drm_pid)) {
165		struct gralloc_drm_bo_t *bo;
166
167		/* check only */
168		if (!drm)
169			return NULL;
170
171		ALOGE("handle: name=%d pfd=%d\n", handle->name,
172			handle->prime_fd);
173		/* create the struct gralloc_drm_bo_t locally */
174		if (handle->name || handle->prime_fd >= 0)
175			bo = drm->drv->alloc(drm->drv, handle);
176		else /* an invalid handle */
177			bo = NULL;
178		if (bo) {
179			bo->drm = drm;
180			bo->imported = 1;
181			bo->handle = handle;
182			bo->refcount = 1;
183		}
184
185		handle->data_owner = gralloc_drm_get_pid();
186		handle->data = bo;
187	}
188
189	return handle->data;
190}
191
192/*
193 * Register a buffer handle.
194 */
195int gralloc_drm_handle_register(buffer_handle_t handle, struct gralloc_drm_t *drm)
196{
197	struct gralloc_drm_bo_t *bo;
198
199	bo = validate_handle(handle, drm);
200	if (!bo)
201		return -EINVAL;
202
203	bo->refcount++;
204
205	return 0;
206}
207
208/*
209 * Unregister a buffer handle.  It is no-op for handles created locally.
210 */
211int gralloc_drm_handle_unregister(buffer_handle_t handle)
212{
213	struct gralloc_drm_bo_t *bo;
214
215	bo = validate_handle(handle, NULL);
216	if (!bo)
217		return -EINVAL;
218
219	gralloc_drm_bo_decref(bo);
220	if (bo->imported)
221		gralloc_drm_bo_decref(bo);
222
223	return 0;
224}
225
226/*
227 * Create a buffer handle.
228 */
229static struct gralloc_drm_handle_t *create_bo_handle(int width,
230		int height, int format, int usage)
231{
232	struct gralloc_drm_handle_t *handle;
233
234	handle = new gralloc_drm_handle_t;
235	if (!handle)
236		return NULL;
237
238	handle->base.version = sizeof(handle->base);
239	handle->base.numInts = GRALLOC_DRM_HANDLE_NUM_INTS;
240	handle->base.numFds = GRALLOC_DRM_HANDLE_NUM_FDS;
241
242	handle->magic = GRALLOC_DRM_HANDLE_MAGIC;
243	handle->width = width;
244	handle->height = height;
245	handle->format = format;
246	handle->usage = usage;
247	handle->prime_fd = -1;
248
249	return handle;
250}
251
252/*
253 * Create a bo.
254 */
255struct gralloc_drm_bo_t *gralloc_drm_bo_create(struct gralloc_drm_t *drm,
256		int width, int height, int format, int usage)
257{
258	struct gralloc_drm_bo_t *bo;
259	struct gralloc_drm_handle_t *handle;
260
261	handle = create_bo_handle(width, height, format, usage);
262	if (!handle)
263		return NULL;
264
265	bo = drm->drv->alloc(drm->drv, handle);
266	if (!bo) {
267		delete handle;
268		return NULL;
269	}
270
271	bo->drm = drm;
272	bo->imported = 0;
273	bo->handle = handle;
274	bo->fb_id = 0;
275	bo->refcount = 1;
276
277	handle->data_owner = gralloc_drm_get_pid();
278	handle->data = bo;
279
280	return bo;
281}
282
283/*
284 * Destroy a bo.
285 */
286static void gralloc_drm_bo_destroy(struct gralloc_drm_bo_t *bo)
287{
288	struct gralloc_drm_handle_t *handle = bo->handle;
289	int imported = bo->imported;
290
291	/* gralloc still has a reference */
292	if (bo->refcount)
293		return;
294
295	bo->drm->drv->free(bo->drm->drv, bo);
296	if (imported) {
297		handle->data_owner = 0;
298		handle->data = 0;
299	}
300	else {
301		delete handle;
302	}
303}
304
305/*
306 * Decrease refcount, if no refs anymore then destroy.
307 */
308void gralloc_drm_bo_decref(struct gralloc_drm_bo_t *bo)
309{
310	if (!--bo->refcount)
311		gralloc_drm_bo_destroy(bo);
312}
313
314/*
315 * Return the bo of a registered handle.
316 */
317struct gralloc_drm_bo_t *gralloc_drm_bo_from_handle(buffer_handle_t handle)
318{
319	return validate_handle(handle, NULL);
320}
321
322/*
323 * Get the buffer handle and stride of a bo.
324 */
325buffer_handle_t gralloc_drm_bo_get_handle(struct gralloc_drm_bo_t *bo, int *stride)
326{
327	if (stride)
328		*stride = bo->handle->stride;
329	return &bo->handle->base;
330}
331
332/*
333 * Query YUV component offsets for a buffer handle
334 */
335void gralloc_drm_resolve_format(buffer_handle_t _handle,
336	uint32_t *pitches, uint32_t *offsets, uint32_t *handles)
337{
338	struct gralloc_drm_handle_t *handle = gralloc_drm_handle(_handle);
339	struct gralloc_drm_bo_t *bo = handle->data;
340	struct gralloc_drm_t *drm = bo->drm;
341
342	/* if handle exists and driver implements resolve_format */
343	if (handle && drm->drv->resolve_format)
344		drm->drv->resolve_format(drm->drv, bo,
345			pitches, offsets, handles);
346}
347
348/*
349 * Lock a bo.  XXX thread-safety?
350 */
351int gralloc_drm_bo_lock(struct gralloc_drm_bo_t *bo,
352		int usage, int x, int y, int w, int h,
353		void **addr)
354{
355	if ((bo->handle->usage & usage) != usage) {
356		/* make FB special for testing software renderer with */
357
358		if (!(bo->handle->usage & GRALLOC_USAGE_HW_FB)
359		&&  !(bo->handle->usage & GRALLOC_USAGE_HW_TEXTURE)) {
360			ALOGE("bo.usage:x%X/usage:x%X is not GRALLOC_USAGE_HW_FB or GRALLOC_USAGE_HW_TEXTURE"
361				,bo->handle->usage,usage);
362			return -EINVAL;
363		}
364	}
365
366	/* allow multiple locks with compatible usages */
367	if (bo->lock_count && (bo->locked_for & usage) != usage)
368		return -EINVAL;
369
370	usage |= bo->locked_for;
371
372	if (usage & (GRALLOC_USAGE_SW_WRITE_MASK |
373		     GRALLOC_USAGE_SW_READ_MASK)) {
374		/* the driver is supposed to wait for the bo */
375		int write = !!(usage & GRALLOC_USAGE_SW_WRITE_MASK);
376		int err = bo->drm->drv->map(bo->drm->drv, bo,
377				x, y, w, h, write, addr);
378		if (err)
379			return err;
380	}
381	else {
382		/* kernel handles the synchronization here */
383	}
384
385	bo->lock_count++;
386	bo->locked_for |= usage;
387
388	return 0;
389}
390
391/*
392 * Unlock a bo.
393 */
394void gralloc_drm_bo_unlock(struct gralloc_drm_bo_t *bo)
395{
396	int mapped = bo->locked_for &
397		(GRALLOC_USAGE_SW_WRITE_MASK | GRALLOC_USAGE_SW_READ_MASK);
398
399	if (!bo->lock_count)
400		return;
401
402	if (mapped)
403		bo->drm->drv->unmap(bo->drm->drv, bo);
404
405	bo->lock_count--;
406	if (!bo->lock_count)
407		bo->locked_for = 0;
408}
409