[linux-block.git] / drivers / gpu / drm / cirrus / cirrus_main.c

/*
 * Copyright 2012 Red Hat
 *
 * This file is subject to the terms and conditions of the GNU General
 * Public License version 2. See the file COPYING in the main
 * directory of this archive for more details.
 *
 * Authors: Matthew Garrett
 *          Dave Airlie
 */
#include "drmP.h"
#include "drm.h"
#include "drm_crtc_helper.h"

#include "cirrus_drv.h"


static void cirrus_user_framebuffer_destroy(struct drm_framebuffer *fb)
{
	struct cirrus_framebuffer *cirrus_fb = to_cirrus_framebuffer(fb);
	if (cirrus_fb->obj)
		drm_gem_object_unreference_unlocked(cirrus_fb->obj);
	drm_framebuffer_cleanup(fb);
	kfree(fb);
}

static int cirrus_user_framebuffer_create_handle(struct drm_framebuffer *fb,
						 struct drm_file *file_priv,
						 unsigned int *handle)
{
	return 0;
}

static const struct drm_framebuffer_funcs cirrus_fb_funcs = {
	.destroy = cirrus_user_framebuffer_destroy,
	.create_handle = cirrus_user_framebuffer_create_handle,
};

int cirrus_framebuffer_init(struct drm_device *dev,
			    struct cirrus_framebuffer *gfb,
			    struct drm_mode_fb_cmd2 *mode_cmd,
			    struct drm_gem_object *obj)
{
	int ret;

	ret = drm_framebuffer_init(dev, &gfb->base, &cirrus_fb_funcs);
	if (ret) {
		DRM_ERROR("drm_framebuffer_init failed: %d\n", ret);
		return ret;
	}
	drm_helper_mode_fill_fb_struct(&gfb->base, mode_cmd);
	gfb->obj = obj;
	return 0;
}

static struct drm_framebuffer *
cirrus_user_framebuffer_create(struct drm_device *dev,
			       struct drm_file *filp,
			       struct drm_mode_fb_cmd2 *mode_cmd)
{
	struct drm_gem_object *obj;
	struct cirrus_framebuffer *cirrus_fb;
	int ret;
	u32 bpp, depth;

	drm_fb_get_bpp_depth(mode_cmd->pixel_format, &depth, &bpp);
	/* cirrus can't handle > 24bpp framebuffers at all */
	if (bpp > 24)
		return ERR_PTR(-EINVAL);

	obj = drm_gem_object_lookup(dev, filp, mode_cmd->handles[0]);
	if (obj == NULL)
		return ERR_PTR(-ENOENT);

	cirrus_fb = kzalloc(sizeof(*cirrus_fb), GFP_KERNEL);
	if (!cirrus_fb) {
		drm_gem_object_unreference_unlocked(obj);
		return ERR_PTR(-ENOMEM);
	}

	ret = cirrus_framebuffer_init(dev, cirrus_fb, mode_cmd, obj);
	if (ret) {
		drm_gem_object_unreference_unlocked(obj);
		kfree(cirrus_fb);
		return ERR_PTR(ret);
	}
	return &cirrus_fb->base;
}

static const struct drm_mode_config_funcs cirrus_mode_funcs = {
	.fb_create = cirrus_user_framebuffer_create,
};

/* Unmap the framebuffer from the core and release the memory */
static void cirrus_vram_fini(struct cirrus_device *cdev)
{
	iounmap(cdev->rmmio);
	cdev->rmmio = NULL;
	if (cdev->mc.vram_base)
		release_mem_region(cdev->mc.vram_base, cdev->mc.vram_size);
}

/* Map the framebuffer from the card and configure the core */
static int cirrus_vram_init(struct cirrus_device *cdev)
{
	/* BAR 0 is VRAM */
	cdev->mc.vram_base = pci_resource_start(cdev->dev->pdev, 0);
	/* We have 4MB of VRAM */
	cdev->mc.vram_size = 4 * 1024 * 1024;

	if (!request_mem_region(cdev->mc.vram_base, cdev->mc.vram_size,
				"cirrusdrmfb_vram")) {
		DRM_ERROR("can't reserve VRAM\n");
		return -ENXIO;
	}

	return 0;
}

/*
 * Our emulated hardware has two sets of memory. One is video RAM and can
 * simply be used as a linear framebuffer - the other provides mmio access
 * to the display registers. The latter can also be accessed via IO port
 * access, but we map the range and use mmio to program them instead
 */

int cirrus_device_init(struct cirrus_device *cdev,
		       struct drm_device *ddev,
		       struct pci_dev *pdev, uint32_t flags)
{
	int ret;

	cdev->dev = ddev;
	cdev->flags = flags;

	/* Hardcode the number of CRTCs to 1 */
	cdev->num_crtc = 1;

	/* BAR 0 is the framebuffer, BAR 1 contains registers */
	cdev->rmmio_base = pci_resource_start(cdev->dev->pdev, 1);
	cdev->rmmio_size = pci_resource_len(cdev->dev->pdev, 1);

	if (!request_mem_region(cdev->rmmio_base, cdev->rmmio_size,
				"cirrusdrmfb_mmio")) {
		DRM_ERROR("can't reserve mmio registers\n");
		return -ENOMEM;
	}

	cdev->rmmio = ioremap(cdev->rmmio_base, cdev->rmmio_size);

	if (cdev->rmmio == NULL)
		return -ENOMEM;

	ret = cirrus_vram_init(cdev);
	if (ret) {
		release_mem_region(cdev->rmmio_base, cdev->rmmio_size);
		return ret;
	}

	return 0;
}

void cirrus_device_fini(struct cirrus_device *cdev)
{
	release_mem_region(cdev->rmmio_base, cdev->rmmio_size);
	cirrus_vram_fini(cdev);
}

/*
 * Functions here will be called by the core once it's bound the driver to
 * a PCI device
 */

int cirrus_driver_load(struct drm_device *dev, unsigned long flags)
{
	struct cirrus_device *cdev;
	int r;

	cdev = kzalloc(sizeof(struct cirrus_device), GFP_KERNEL);
	if (cdev == NULL)
		return -ENOMEM;
	dev->dev_private = (void *)cdev;

	r = cirrus_device_init(cdev, dev, dev->pdev, flags);
	if (r) {
		dev_err(&dev->pdev->dev, "Fatal error during GPU init: %d\n", r);
		goto out;
	}

	r = cirrus_mm_init(cdev);
	if (r)
		dev_err(&dev->pdev->dev, "fatal err on mm init\n");

	r = cirrus_modeset_init(cdev);
	if (r)
		dev_err(&dev->pdev->dev, "Fatal error during modeset init: %d\n", r);

	dev->mode_config.funcs = (void *)&cirrus_mode_funcs;
out:
	if (r)
		cirrus_driver_unload(dev);
	return r;
}

int cirrus_driver_unload(struct drm_device *dev)
{
	struct cirrus_device *cdev = dev->dev_private;

	if (cdev == NULL)
		return 0;
	cirrus_modeset_fini(cdev);
	cirrus_mm_fini(cdev);
	cirrus_device_fini(cdev);
	kfree(cdev);
	dev->dev_private = NULL;
	return 0;
}

int cirrus_gem_create(struct drm_device *dev,
		   u32 size, bool iskernel,
		   struct drm_gem_object **obj)
{
	struct cirrus_bo *cirrusbo;
	int ret;

	*obj = NULL;

	size = roundup(size, PAGE_SIZE);
	if (size == 0)
		return -EINVAL;

	ret = cirrus_bo_create(dev, size, 0, 0, &cirrusbo);
	if (ret) {
		if (ret != -ERESTARTSYS)
			DRM_ERROR("failed to allocate GEM object\n");
		return ret;
	}
	*obj = &cirrusbo->gem;
	return 0;
}

int cirrus_dumb_create(struct drm_file *file,
		    struct drm_device *dev,
		    struct drm_mode_create_dumb *args)
{
	int ret;
	struct drm_gem_object *gobj;
	u32 handle;

	args->pitch = args->width * ((args->bpp + 7) / 8);
	args->size = args->pitch * args->height;

	ret = cirrus_gem_create(dev, args->size, false,
			     &gobj);
	if (ret)
		return ret;

	ret = drm_gem_handle_create(file, gobj, &handle);
	drm_gem_object_unreference_unlocked(gobj);
	if (ret)
		return ret;

	args->handle = handle;
	return 0;
}

int cirrus_dumb_destroy(struct drm_file *file,
		     struct drm_device *dev,
		     uint32_t handle)
{
	return drm_gem_handle_delete(file, handle);
}

int cirrus_gem_init_object(struct drm_gem_object *obj)
{
	BUG();
	return 0;
}

void cirrus_bo_unref(struct cirrus_bo **bo)
{
	struct ttm_buffer_object *tbo;

	if ((*bo) == NULL)
		return;

	tbo = &((*bo)->bo);
	ttm_bo_unref(&tbo);
	if (tbo == NULL)
		*bo = NULL;

}

void cirrus_gem_free_object(struct drm_gem_object *obj)
{
	struct cirrus_bo *cirrus_bo = gem_to_cirrus_bo(obj);

	if (!cirrus_bo)
		return;
	cirrus_bo_unref(&cirrus_bo);
}


static inline u64 cirrus_bo_mmap_offset(struct cirrus_bo *bo)
{
	return bo->bo.addr_space_offset;
}

int
cirrus_dumb_mmap_offset(struct drm_file *file,
		     struct drm_device *dev,
		     uint32_t handle,
		     uint64_t *offset)
{
	struct drm_gem_object *obj;
	int ret;
	struct cirrus_bo *bo;

	mutex_lock(&dev->struct_mutex);
	obj = drm_gem_object_lookup(dev, file, handle);
	if (obj == NULL) {
		ret = -ENOENT;
		goto out_unlock;
	}

	bo = gem_to_cirrus_bo(obj);
	*offset = cirrus_bo_mmap_offset(bo);

	drm_gem_object_unreference(obj);
	ret = 0;
out_unlock:
	mutex_unlock(&dev->struct_mutex);
	return ret;

}
Commit	Line	Data
f9aa76a8 DA	1	/*
	2	* Copyright 2012 Red Hat
	3	*
	4	* This file is subject to the terms and conditions of the GNU General
	5	* Public License version 2. See the file COPYING in the main
	6	* directory of this archive for more details.
	7	*
	8	* Authors: Matthew Garrett
	9	* Dave Airlie
	10	*/
	11	#include "drmP.h"
	12	#include "drm.h"
	13	#include "drm_crtc_helper.h"
	14
	15	#include "cirrus_drv.h"
	16
	17
	18	static void cirrus_user_framebuffer_destroy(struct drm_framebuffer *fb)
	19	{
	20	struct cirrus_framebuffer *cirrus_fb = to_cirrus_framebuffer(fb);
	21	if (cirrus_fb->obj)
	22	drm_gem_object_unreference_unlocked(cirrus_fb->obj);
	23	drm_framebuffer_cleanup(fb);
	24	kfree(fb);
	25	}
	26
	27	static int cirrus_user_framebuffer_create_handle(struct drm_framebuffer *fb,
	28	struct drm_file *file_priv,
	29	unsigned int *handle)
	30	{
	31	return 0;
	32	}
	33
	34	static const struct drm_framebuffer_funcs cirrus_fb_funcs = {
	35	.destroy = cirrus_user_framebuffer_destroy,
	36	.create_handle = cirrus_user_framebuffer_create_handle,
	37	};
	38
	39	int cirrus_framebuffer_init(struct drm_device *dev,
	40	struct cirrus_framebuffer *gfb,
	41	struct drm_mode_fb_cmd2 *mode_cmd,
	42	struct drm_gem_object *obj)
	43	{
	44	int ret;
	45
	46	ret = drm_framebuffer_init(dev, &gfb->base, &cirrus_fb_funcs);
	47	if (ret) {
	48	DRM_ERROR("drm_framebuffer_init failed: %d\n", ret);
	49	return ret;
	50	}
	51	drm_helper_mode_fill_fb_struct(&gfb->base, mode_cmd);
	52	gfb->obj = obj;
	53	return 0;
	54	}
	55
	56	static struct drm_framebuffer *
	57	cirrus_user_framebuffer_create(struct drm_device *dev,
	58	struct drm_file *filp,
	59	struct drm_mode_fb_cmd2 *mode_cmd)
	60	{
	61	struct drm_gem_object *obj;
	62	struct cirrus_framebuffer *cirrus_fb;
	63	int ret;
	64	u32 bpp, depth;
65
66	drm_fb_get_bpp_depth(mode_cmd->pixel_format, &depth, &bpp);
67	/* cirrus can't handle > 24bpp framebuffers at all */
68	if (bpp > 24)
69	return ERR_PTR(-EINVAL);
70
71	obj = drm_gem_object_lookup(dev, filp, mode_cmd->handles[0]);
72	if (obj == NULL)
73	return ERR_PTR(-ENOENT);
74
75	cirrus_fb = kzalloc(sizeof(*cirrus_fb), GFP_KERNEL);
76	if (!cirrus_fb) {
77	drm_gem_object_unreference_unlocked(obj);
78	return ERR_PTR(-ENOMEM);
79	}
80
81	ret = cirrus_framebuffer_init(dev, cirrus_fb, mode_cmd, obj);
82	if (ret) {
83	drm_gem_object_unreference_unlocked(obj);
84	kfree(cirrus_fb);
85	return ERR_PTR(ret);
86	}
87	return &cirrus_fb->base;
88	}
89
90	static const struct drm_mode_config_funcs cirrus_mode_funcs = {
91	.fb_create = cirrus_user_framebuffer_create,
92	};
93
94	/* Unmap the framebuffer from the core and release the memory */
95	static void cirrus_vram_fini(struct cirrus_device *cdev)
96	{
97	iounmap(cdev->rmmio);
98	cdev->rmmio = NULL;
99	if (cdev->mc.vram_base)
100	release_mem_region(cdev->mc.vram_base, cdev->mc.vram_size);
101	}
102
103	/* Map the framebuffer from the card and configure the core */
104	static int cirrus_vram_init(struct cirrus_device *cdev)
105	{
106	/* BAR 0 is VRAM */
107	cdev->mc.vram_base = pci_resource_start(cdev->dev->pdev, 0);
108	/* We have 4MB of VRAM */
109	cdev->mc.vram_size = 4 * 1024 * 1024;
110
111	if (!request_mem_region(cdev->mc.vram_base, cdev->mc.vram_size,
112	"cirrusdrmfb_vram")) {
113	DRM_ERROR("can't reserve VRAM\n");
114	return -ENXIO;
115	}
116
117	return 0;
118	}
119
120	/*
121	* Our emulated hardware has two sets of memory. One is video RAM and can
122	* simply be used as a linear framebuffer - the other provides mmio access
123	* to the display registers. The latter can also be accessed via IO port
124	* access, but we map the range and use mmio to program them instead
125	*/
126
127	int cirrus_device_init(struct cirrus_device *cdev,
128	struct drm_device *ddev,
129	struct pci_dev *pdev, uint32_t flags)
130	{
131	int ret;
132
133	cdev->dev = ddev;
134	cdev->flags = flags;
135
136	/* Hardcode the number of CRTCs to 1 */
137	cdev->num_crtc = 1;
138
139	/* BAR 0 is the framebuffer, BAR 1 contains registers */
140	cdev->rmmio_base = pci_resource_start(cdev->dev->pdev, 1);
141	cdev->rmmio_size = pci_resource_len(cdev->dev->pdev, 1);
142
143	if (!request_mem_region(cdev->rmmio_base, cdev->rmmio_size,
144	"cirrusdrmfb_mmio")) {
145	DRM_ERROR("can't reserve mmio registers\n");
146	return -ENOMEM;
147	}
148
149	cdev->rmmio = ioremap(cdev->rmmio_base, cdev->rmmio_size);
150
151	if (cdev->rmmio == NULL)
152	return -ENOMEM;
153
154	ret = cirrus_vram_init(cdev);
155	if (ret) {
156	release_mem_region(cdev->rmmio_base, cdev->rmmio_size);
157	return ret;
158	}
159
160	return 0;
161	}
162
163	void cirrus_device_fini(struct cirrus_device *cdev)
164	{
165	release_mem_region(cdev->rmmio_base, cdev->rmmio_size);
166	cirrus_vram_fini(cdev);
167	}
168
169	/*
170	* Functions here will be called by the core once it's bound the driver to
171	* a PCI device
172	*/
173
174	int cirrus_driver_load(struct drm_device *dev, unsigned long flags)
175	{
176	struct cirrus_device *cdev;
177	int r;
178
179	cdev = kzalloc(sizeof(struct cirrus_device), GFP_KERNEL);
180	if (cdev == NULL)
181	return -ENOMEM;
182	dev->dev_private = (void *)cdev;
183
184	r = cirrus_device_init(cdev, dev, dev->pdev, flags);
185	if (r) {
186	dev_err(&dev->pdev->dev, "Fatal error during GPU init: %d\n", r);
187	goto out;
188	}
189
190	r = cirrus_mm_init(cdev);
191	if (r)
192	dev_err(&dev->pdev->dev, "fatal err on mm init\n");
193
194	r = cirrus_modeset_init(cdev);
195	if (r)
196	dev_err(&dev->pdev->dev, "Fatal error during modeset init: %d\n", r);
197
198	dev->mode_config.funcs = (void *)&cirrus_mode_funcs;
199	out:
200	if (r)
201	cirrus_driver_unload(dev);
202	return r;
203	}
204
205	int cirrus_driver_unload(struct drm_device *dev)
206	{
207	struct cirrus_device *cdev = dev->dev_private;
208
209	if (cdev == NULL)
210	return 0;
211	cirrus_modeset_fini(cdev);
212	cirrus_mm_fini(cdev);
213	cirrus_device_fini(cdev);
214	kfree(cdev);
215	dev->dev_private = NULL;
216	return 0;
217	}
218
219	int cirrus_gem_create(struct drm_device *dev,
220	u32 size, bool iskernel,
221	struct drm_gem_object **obj)
222	{
223	struct cirrus_bo *cirrusbo;
224	int ret;
225
226	*obj = NULL;
227
228	size = roundup(size, PAGE_SIZE);
229	if (size == 0)
230	return -EINVAL;
231
232	ret = cirrus_bo_create(dev, size, 0, 0, &cirrusbo);
233	if (ret) {
234	if (ret != -ERESTARTSYS)
235	DRM_ERROR("failed to allocate GEM object\n");
236	return ret;
237	}
238	*obj = &cirrusbo->gem;
239	return 0;
240	}
241
242	int cirrus_dumb_create(struct drm_file *file,
243	struct drm_device *dev,
244	struct drm_mode_create_dumb *args)
245	{
246	int ret;
247	struct drm_gem_object *gobj;
248	u32 handle;
249
250	args->pitch = args->width * ((args->bpp + 7) / 8);
251	args->size = args->pitch * args->height;
252
253	ret = cirrus_gem_create(dev, args->size, false,
254	&gobj);
255	if (ret)
256	return ret;
257
258	ret = drm_gem_handle_create(file, gobj, &handle);
259	drm_gem_object_unreference_unlocked(gobj);
260	if (ret)
261	return ret;
262
263	args->handle = handle;
264	return 0;
265	}
266
267	int cirrus_dumb_destroy(struct drm_file *file,
268	struct drm_device *dev,
269	uint32_t handle)
270	{
271	return drm_gem_handle_delete(file, handle);
272	}
273
274	int cirrus_gem_init_object(struct drm_gem_object *obj)
275	{
276	BUG();
277	return 0;
278	}
279
280	void cirrus_bo_unref(struct cirrus_bo **bo)
281	{
282	struct ttm_buffer_object *tbo;
283
284	if ((*bo) == NULL)
285	return;
286
287	tbo = &((*bo)->bo);
288	ttm_bo_unref(&tbo);
289	if (tbo == NULL)
290	*bo = NULL;
291
292	}
293
294	void cirrus_gem_free_object(struct drm_gem_object *obj)
295	{
296	struct cirrus_bo *cirrus_bo = gem_to_cirrus_bo(obj);
297
298	if (!cirrus_bo)
299	return;
300	cirrus_bo_unref(&cirrus_bo);
301	}
302
303
304	static inline u64 cirrus_bo_mmap_offset(struct cirrus_bo *bo)
305	{
306	return bo->bo.addr_space_offset;
307	}
308
309	int
310	cirrus_dumb_mmap_offset(struct drm_file *file,
311	struct drm_device *dev,
312	uint32_t handle,
313	uint64_t *offset)
314	{
315	struct drm_gem_object *obj;
316	int ret;
317	struct cirrus_bo *bo;
318
319	mutex_lock(&dev->struct_mutex);
320	obj = drm_gem_object_lookup(dev, file, handle);
321	if (obj == NULL) {
322	ret = -ENOENT;
323	goto out_unlock;
324	}
325
326	bo = gem_to_cirrus_bo(obj);
327	*offset = cirrus_bo_mmap_offset(bo);
328
329	drm_gem_object_unreference(obj);
330	ret = 0;
331	out_unlock:
332	mutex_unlock(&dev->struct_mutex);
333	return ret;
334
335	}