1/*
  2 * Copyright © 2007 David Airlie
  3 *
  4 * Permission is hereby granted, free of charge, to any person obtaining a
  5 * copy of this software and associated documentation files (the "Software"),
  6 * to deal in the Software without restriction, including without limitation
  7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  8 * and/or sell copies of the Software, and to permit persons to whom the
  9 * Software is furnished to do so, subject to the following conditions:
 10 *
 11 * The above copyright notice and this permission notice (including the next
 12 * paragraph) shall be included in all copies or substantial portions of the
 13 * 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 * Authors:
 24 *     David Airlie
 25 */
 26#include <linux/module.h>
 27#include <linux/slab.h>
 28#include <linux/pm_runtime.h>
 29
 30#include <drm/drmP.h>
 31#include <drm/drm_crtc.h>
 32#include <drm/drm_crtc_helper.h>
 33#include <drm/radeon_drm.h>
 34#include "radeon.h"
 35
 36#include <drm/drm_fb_helper.h>
 37
 38#include <linux/vga_switcheroo.h>
 39
 40/* object hierarchy -
 41 * this contains a helper + a radeon fb
 42 * the helper contains a pointer to radeon framebuffer baseclass.
 43 */
 44struct radeon_fbdev {
 45	struct drm_fb_helper helper;
 46	struct radeon_framebuffer rfb;
 47	struct radeon_device *rdev;
 48};
 49
 50static int
 51radeonfb_open(struct fb_info *info, int user)
 52{
 53	struct radeon_fbdev *rfbdev = info->par;
 54	struct radeon_device *rdev = rfbdev->rdev;
 55	int ret = pm_runtime_get_sync(rdev->ddev->dev);
 56	if (ret < 0 && ret != -EACCES) {
 57		pm_runtime_mark_last_busy(rdev->ddev->dev);
 58		pm_runtime_put_autosuspend(rdev->ddev->dev);
 59		return ret;
 60	}
 61	return 0;
 62}
 63
 64static int
 65radeonfb_release(struct fb_info *info, int user)
 66{
 67	struct radeon_fbdev *rfbdev = info->par;
 68	struct radeon_device *rdev = rfbdev->rdev;
 69
 70	pm_runtime_mark_last_busy(rdev->ddev->dev);
 71	pm_runtime_put_autosuspend(rdev->ddev->dev);
 72	return 0;
 73}
 74
 75static struct fb_ops radeonfb_ops = {
 76	.owner = THIS_MODULE,
 77	DRM_FB_HELPER_DEFAULT_OPS,
 78	.fb_open = radeonfb_open,
 79	.fb_release = radeonfb_release,
 80	.fb_fillrect = drm_fb_helper_cfb_fillrect,
 81	.fb_copyarea = drm_fb_helper_cfb_copyarea,
 82	.fb_imageblit = drm_fb_helper_cfb_imageblit,
 83};
 84
 85
 86int radeon_align_pitch(struct radeon_device *rdev, int width, int cpp, bool tiled)
 87{
 88	int aligned = width;
 89	int align_large = (ASIC_IS_AVIVO(rdev)) || tiled;
 90	int pitch_mask = 0;
 91
 92	switch (cpp) {
 93	case 1:
 94		pitch_mask = align_large ? 255 : 127;
 95		break;
 96	case 2:
 97		pitch_mask = align_large ? 127 : 31;
 98		break;
 99	case 3:
100	case 4:
101		pitch_mask = align_large ? 63 : 15;
102		break;
103	}
104
105	aligned += pitch_mask;
106	aligned &= ~pitch_mask;
107	return aligned * cpp;
108}
109
110static void radeonfb_destroy_pinned_object(struct drm_gem_object *gobj)
111{
112	struct radeon_bo *rbo = gem_to_radeon_bo(gobj);
113	int ret;
114
115	ret = radeon_bo_reserve(rbo, false);
116	if (likely(ret == 0)) {
117		radeon_bo_kunmap(rbo);
118		radeon_bo_unpin(rbo);
119		radeon_bo_unreserve(rbo);
120	}
121	drm_gem_object_unreference_unlocked(gobj);
122}
123
124static int radeonfb_create_pinned_object(struct radeon_fbdev *rfbdev,
125					 struct drm_mode_fb_cmd2 *mode_cmd,
126					 struct drm_gem_object **gobj_p)
127{
128	struct radeon_device *rdev = rfbdev->rdev;
129	struct drm_gem_object *gobj = NULL;
130	struct radeon_bo *rbo = NULL;
131	bool fb_tiled = false; /* useful for testing */
132	u32 tiling_flags = 0;
133	int ret;
134	int aligned_size, size;
135	int height = mode_cmd->height;
136	u32 cpp;
137
138	cpp = drm_format_plane_cpp(mode_cmd->pixel_format, 0);
139
140	/* need to align pitch with crtc limits */
141	mode_cmd->pitches[0] = radeon_align_pitch(rdev, mode_cmd->width, cpp,
142						  fb_tiled);
143
144	if (rdev->family >= CHIP_R600)
145		height = ALIGN(mode_cmd->height, 8);
146	size = mode_cmd->pitches[0] * height;
147	aligned_size = ALIGN(size, PAGE_SIZE);
148	ret = radeon_gem_object_create(rdev, aligned_size, 0,
149				       RADEON_GEM_DOMAIN_VRAM,
150				       0, true, &gobj);
151	if (ret) {
152		printk(KERN_ERR "failed to allocate framebuffer (%d)\n",
153		       aligned_size);
154		return -ENOMEM;
155	}
156	rbo = gem_to_radeon_bo(gobj);
157
158	if (fb_tiled)
159		tiling_flags = RADEON_TILING_MACRO;
160
161#ifdef __BIG_ENDIAN
162	switch (cpp) {
163	case 4:
164		tiling_flags |= RADEON_TILING_SWAP_32BIT;
165		break;
166	case 2:
167		tiling_flags |= RADEON_TILING_SWAP_16BIT;
168	default:
169		break;
170	}
171#endif
172
173	if (tiling_flags) {
174		ret = radeon_bo_set_tiling_flags(rbo,
175						 tiling_flags | RADEON_TILING_SURFACE,
176						 mode_cmd->pitches[0]);
177		if (ret)
178			dev_err(rdev->dev, "FB failed to set tiling flags\n");
179	}
180
181
182	ret = radeon_bo_reserve(rbo, false);
183	if (unlikely(ret != 0))
184		goto out_unref;
185	/* Only 27 bit offset for legacy CRTC */
186	ret = radeon_bo_pin_restricted(rbo, RADEON_GEM_DOMAIN_VRAM,
187				       ASIC_IS_AVIVO(rdev) ? 0 : 1 << 27,
188				       NULL);
189	if (ret) {
190		radeon_bo_unreserve(rbo);
191		goto out_unref;
192	}
193	if (fb_tiled)
194		radeon_bo_check_tiling(rbo, 0, 0);
195	ret = radeon_bo_kmap(rbo, NULL);
196	radeon_bo_unreserve(rbo);
197	if (ret) {
198		goto out_unref;
199	}
200
201	*gobj_p = gobj;
202	return 0;
203out_unref:
204	radeonfb_destroy_pinned_object(gobj);
205	*gobj_p = NULL;
206	return ret;
207}
208
209static int radeonfb_create(struct drm_fb_helper *helper,
210			   struct drm_fb_helper_surface_size *sizes)
211{
212	struct radeon_fbdev *rfbdev =
213		container_of(helper, struct radeon_fbdev, helper);
214	struct radeon_device *rdev = rfbdev->rdev;
215	struct fb_info *info;
216	struct drm_framebuffer *fb = NULL;
217	struct drm_mode_fb_cmd2 mode_cmd;
218	struct drm_gem_object *gobj = NULL;
219	struct radeon_bo *rbo = NULL;
220	int ret;
221	unsigned long tmp;
222
223	mode_cmd.width = sizes->surface_width;
224	mode_cmd.height = sizes->surface_height;
225
226	/* avivo can't scanout real 24bpp */
227	if ((sizes->surface_bpp == 24) && ASIC_IS_AVIVO(rdev))
228		sizes->surface_bpp = 32;
229
230	mode_cmd.pixel_format = drm_mode_legacy_fb_format(sizes->surface_bpp,
231							  sizes->surface_depth);
232
233	ret = radeonfb_create_pinned_object(rfbdev, &mode_cmd, &gobj);
234	if (ret) {
235		DRM_ERROR("failed to create fbcon object %d\n", ret);
236		return ret;
237	}
238
239	rbo = gem_to_radeon_bo(gobj);
240
241	/* okay we have an object now allocate the framebuffer */
242	info = drm_fb_helper_alloc_fbi(helper);
243	if (IS_ERR(info)) {
244		ret = PTR_ERR(info);
245		goto out_unref;
246	}
247
248	info->par = rfbdev;
249	info->skip_vt_switch = true;
250
251	ret = radeon_framebuffer_init(rdev->ddev, &rfbdev->rfb, &mode_cmd, gobj);
252	if (ret) {
253		DRM_ERROR("failed to initialize framebuffer %d\n", ret);
254		goto out_destroy_fbi;
255	}
256
257	fb = &rfbdev->rfb.base;
258
259	/* setup helper */
260	rfbdev->helper.fb = fb;
261
262	memset_io(rbo->kptr, 0x0, radeon_bo_size(rbo));
263
264	strcpy(info->fix.id, "radeondrmfb");
265
266	drm_fb_helper_fill_fix(info, fb->pitches[0], fb->depth);
267
268	info->flags = FBINFO_DEFAULT | FBINFO_CAN_FORCE_OUTPUT;
269	info->fbops = &radeonfb_ops;
270
271	tmp = radeon_bo_gpu_offset(rbo) - rdev->mc.vram_start;
272	info->fix.smem_start = rdev->mc.aper_base + tmp;
273	info->fix.smem_len = radeon_bo_size(rbo);
274	info->screen_base = rbo->kptr;
275	info->screen_size = radeon_bo_size(rbo);
276
277	drm_fb_helper_fill_var(info, &rfbdev->helper, sizes->fb_width, sizes->fb_height);
278
279	/* setup aperture base/size for vesafb takeover */
280	info->apertures->ranges[0].base = rdev->ddev->mode_config.fb_base;
281	info->apertures->ranges[0].size = rdev->mc.aper_size;
282
283	/* Use default scratch pixmap (info->pixmap.flags = FB_PIXMAP_SYSTEM) */
284
285	if (info->screen_base == NULL) {
286		ret = -ENOSPC;
287		goto out_destroy_fbi;
288	}
289
290	DRM_INFO("fb mappable at 0x%lX\n",  info->fix.smem_start);
291	DRM_INFO("vram apper at 0x%lX\n",  (unsigned long)rdev->mc.aper_base);
292	DRM_INFO("size %lu\n", (unsigned long)radeon_bo_size(rbo));
293	DRM_INFO("fb depth is %d\n", fb->depth);
294	DRM_INFO("   pitch is %d\n", fb->pitches[0]);
295
296	vga_switcheroo_client_fb_set(rdev->ddev->pdev, info);
297	return 0;
298
299out_destroy_fbi:
300	drm_fb_helper_release_fbi(helper);
301out_unref:
302	if (rbo) {
303
304	}
305	if (fb && ret) {
306		drm_gem_object_unreference_unlocked(gobj);
307		drm_framebuffer_unregister_private(fb);
308		drm_framebuffer_cleanup(fb);
309		kfree(fb);
310	}
311	return ret;
312}
313
314void radeon_fb_output_poll_changed(struct radeon_device *rdev)
315{
316	if (rdev->mode_info.rfbdev)
317		drm_fb_helper_hotplug_event(&rdev->mode_info.rfbdev->helper);
318}
319
320static int radeon_fbdev_destroy(struct drm_device *dev, struct radeon_fbdev *rfbdev)
321{
322	struct radeon_framebuffer *rfb = &rfbdev->rfb;
323
324	drm_fb_helper_unregister_fbi(&rfbdev->helper);
325	drm_fb_helper_release_fbi(&rfbdev->helper);
326
327	if (rfb->obj) {
328		radeonfb_destroy_pinned_object(rfb->obj);
329		rfb->obj = NULL;
330	}
331	drm_fb_helper_fini(&rfbdev->helper);
332	drm_framebuffer_unregister_private(&rfb->base);
333	drm_framebuffer_cleanup(&rfb->base);
334
335	return 0;
336}
337
338static const struct drm_fb_helper_funcs radeon_fb_helper_funcs = {
339	.gamma_set = radeon_crtc_fb_gamma_set,
340	.gamma_get = radeon_crtc_fb_gamma_get,
341	.fb_probe = radeonfb_create,
342};
343
344int radeon_fbdev_init(struct radeon_device *rdev)
345{
346	struct radeon_fbdev *rfbdev;
347	int bpp_sel = 32;
348	int ret;
349
350	/* don't enable fbdev if no connectors */
351	if (list_empty(&rdev->ddev->mode_config.connector_list))
352		return 0;
353
354	/* select 8 bpp console on RN50 or 16MB cards */
355	if (ASIC_IS_RN50(rdev) || rdev->mc.real_vram_size <= (32*1024*1024))
356		bpp_sel = 8;
357
358	rfbdev = kzalloc(sizeof(struct radeon_fbdev), GFP_KERNEL);
359	if (!rfbdev)
360		return -ENOMEM;
361
362	rfbdev->rdev = rdev;
363	rdev->mode_info.rfbdev = rfbdev;
364
365	drm_fb_helper_prepare(rdev->ddev, &rfbdev->helper,
366			      &radeon_fb_helper_funcs);
367
368	ret = drm_fb_helper_init(rdev->ddev, &rfbdev->helper,
369				 rdev->num_crtc,
370				 RADEONFB_CONN_LIMIT);
371	if (ret)
372		goto free;
373
374	ret = drm_fb_helper_single_add_all_connectors(&rfbdev->helper);
375	if (ret)
376		goto fini;
377
378	/* disable all the possible outputs/crtcs before entering KMS mode */
379	drm_helper_disable_unused_functions(rdev->ddev);
380
381	ret = drm_fb_helper_initial_config(&rfbdev->helper, bpp_sel);
382	if (ret)
383		goto fini;
384
385	return 0;
386
387fini:
388	drm_fb_helper_fini(&rfbdev->helper);
389free:
390	kfree(rfbdev);
391	return ret;
392}
393
394void radeon_fbdev_fini(struct radeon_device *rdev)
395{
396	if (!rdev->mode_info.rfbdev)
397		return;
398
399	radeon_fbdev_destroy(rdev->ddev, rdev->mode_info.rfbdev);
400	kfree(rdev->mode_info.rfbdev);
401	rdev->mode_info.rfbdev = NULL;
402}
403
404void radeon_fbdev_set_suspend(struct radeon_device *rdev, int state)
405{
406	if (rdev->mode_info.rfbdev)
407		drm_fb_helper_set_suspend(&rdev->mode_info.rfbdev->helper, state);
408}
409
410bool radeon_fbdev_robj_is_fb(struct radeon_device *rdev, struct radeon_bo *robj)
411{
412	if (!rdev->mode_info.rfbdev)
413		return false;
414
415	if (robj == gem_to_radeon_bo(rdev->mode_info.rfbdev->rfb.obj))
416		return true;
417	return false;
418}
419
420void radeon_fb_add_connector(struct radeon_device *rdev, struct drm_connector *connector)
421{
422	if (rdev->mode_info.rfbdev)
423		drm_fb_helper_add_one_connector(&rdev->mode_info.rfbdev->helper, connector);
424}
425
426void radeon_fb_remove_connector(struct radeon_device *rdev, struct drm_connector *connector)
427{
428	if (rdev->mode_info.rfbdev)
429		drm_fb_helper_remove_one_connector(&rdev->mode_info.rfbdev->helper, connector);
430}
431
432void radeon_fbdev_restore_mode(struct radeon_device *rdev)
433{
434	struct radeon_fbdev *rfbdev = rdev->mode_info.rfbdev;
435	struct drm_fb_helper *fb_helper;
436	int ret;
437
438	if (!rfbdev)
439		return;
440
441	fb_helper = &rfbdev->helper;
442
443	ret = drm_fb_helper_restore_fbdev_mode_unlocked(fb_helper);
444	if (ret)
445		DRM_DEBUG("failed to restore crtc mode\n");
446}