1 /*
2 * Copyright 2012 Red Hat Inc.
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the
6 * "Software"), to deal in the Software without restriction, including
7 * without limitation the rights to use, copy, modify, merge, publish,
8 * distribute, sub license, and/or sell copies of the Software, and to
9 * permit persons to whom the Software is furnished to do so, subject to
10 * the following conditions:
11 *
12 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
13 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
14 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
15 * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
16 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
17 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
18 * USE OR OTHER DEALINGS IN THE SOFTWARE.
19 *
20 * The above copyright notice and this permission notice (including the
21 * next paragraph) shall be included in all copies or substantial portions
22 * of the Software.
23 *
24 */
25 /*
26 * Authors: Dave Airlie <airlied@redhat.com>
27 */
28 #include <linux/module.h>
29 #include <linux/kernel.h>
30 #include <linux/errno.h>
31 #include <linux/string.h>
32 #include <linux/mm.h>
33 #include <linux/tty.h>
34 #include <linux/sysrq.h>
35 #include <linux/delay.h>
36 #include <linux/init.h>
37
38
39 #include <drm/drmP.h>
40 #include <drm/drm_crtc.h>
41 #include <drm/drm_fb_helper.h>
42 #include <drm/drm_crtc_helper.h>
43 #include "ast_drv.h"
44
ast_dirty_update(struct ast_fbdev * afbdev,int x,int y,int width,int height)45 static void ast_dirty_update(struct ast_fbdev *afbdev,
46 int x, int y, int width, int height)
47 {
48 int i;
49 struct drm_gem_object *obj;
50 struct ast_bo *bo;
51 int src_offset, dst_offset;
52 int bpp = afbdev->afb.base.format->cpp[0];
53 int ret = -EBUSY;
54 bool unmap = false;
55 bool store_for_later = false;
56 int x2, y2;
57 unsigned long flags;
58
59 obj = afbdev->afb.obj;
60 bo = gem_to_ast_bo(obj);
61
62 /*
63 * try and reserve the BO, if we fail with busy
64 * then the BO is being moved and we should
65 * store up the damage until later.
66 */
67 if (drm_can_sleep())
68 ret = ast_bo_reserve(bo, true);
69 if (ret) {
70 if (ret != -EBUSY)
71 return;
72
73 store_for_later = true;
74 }
75
76 x2 = x + width - 1;
77 y2 = y + height - 1;
78 spin_lock_irqsave(&afbdev->dirty_lock, flags);
79
80 if (afbdev->y1 < y)
81 y = afbdev->y1;
82 if (afbdev->y2 > y2)
83 y2 = afbdev->y2;
84 if (afbdev->x1 < x)
85 x = afbdev->x1;
86 if (afbdev->x2 > x2)
87 x2 = afbdev->x2;
88
89 if (store_for_later) {
90 afbdev->x1 = x;
91 afbdev->x2 = x2;
92 afbdev->y1 = y;
93 afbdev->y2 = y2;
94 spin_unlock_irqrestore(&afbdev->dirty_lock, flags);
95 return;
96 }
97
98 afbdev->x1 = afbdev->y1 = INT_MAX;
99 afbdev->x2 = afbdev->y2 = 0;
100 spin_unlock_irqrestore(&afbdev->dirty_lock, flags);
101
102 if (!bo->kmap.virtual) {
103 ret = ttm_bo_kmap(&bo->bo, 0, bo->bo.num_pages, &bo->kmap);
104 if (ret) {
105 DRM_ERROR("failed to kmap fb updates\n");
106 ast_bo_unreserve(bo);
107 return;
108 }
109 unmap = true;
110 }
111 for (i = y; i <= y2; i++) {
112 /* assume equal stride for now */
113 src_offset = dst_offset = i * afbdev->afb.base.pitches[0] + (x * bpp);
114 memcpy_toio(bo->kmap.virtual + src_offset, afbdev->sysram + src_offset, (x2 - x + 1) * bpp);
115
116 }
117 if (unmap)
118 ttm_bo_kunmap(&bo->kmap);
119
120 ast_bo_unreserve(bo);
121 }
122
ast_fillrect(struct fb_info * info,const struct fb_fillrect * rect)123 static void ast_fillrect(struct fb_info *info,
124 const struct fb_fillrect *rect)
125 {
126 struct ast_fbdev *afbdev = info->par;
127 drm_fb_helper_sys_fillrect(info, rect);
128 ast_dirty_update(afbdev, rect->dx, rect->dy, rect->width,
129 rect->height);
130 }
131
ast_copyarea(struct fb_info * info,const struct fb_copyarea * area)132 static void ast_copyarea(struct fb_info *info,
133 const struct fb_copyarea *area)
134 {
135 struct ast_fbdev *afbdev = info->par;
136 drm_fb_helper_sys_copyarea(info, area);
137 ast_dirty_update(afbdev, area->dx, area->dy, area->width,
138 area->height);
139 }
140
ast_imageblit(struct fb_info * info,const struct fb_image * image)141 static void ast_imageblit(struct fb_info *info,
142 const struct fb_image *image)
143 {
144 struct ast_fbdev *afbdev = info->par;
145 drm_fb_helper_sys_imageblit(info, image);
146 ast_dirty_update(afbdev, image->dx, image->dy, image->width,
147 image->height);
148 }
149
150 static struct fb_ops astfb_ops = {
151 .owner = THIS_MODULE,
152 .fb_check_var = drm_fb_helper_check_var,
153 .fb_set_par = drm_fb_helper_set_par,
154 .fb_fillrect = ast_fillrect,
155 .fb_copyarea = ast_copyarea,
156 .fb_imageblit = ast_imageblit,
157 .fb_pan_display = drm_fb_helper_pan_display,
158 .fb_blank = drm_fb_helper_blank,
159 .fb_setcmap = drm_fb_helper_setcmap,
160 .fb_debug_enter = drm_fb_helper_debug_enter,
161 .fb_debug_leave = drm_fb_helper_debug_leave,
162 };
163
astfb_create_object(struct ast_fbdev * afbdev,const struct drm_mode_fb_cmd2 * mode_cmd,struct drm_gem_object ** gobj_p)164 static int astfb_create_object(struct ast_fbdev *afbdev,
165 const struct drm_mode_fb_cmd2 *mode_cmd,
166 struct drm_gem_object **gobj_p)
167 {
168 struct drm_device *dev = afbdev->helper.dev;
169 u32 size;
170 struct drm_gem_object *gobj;
171 int ret = 0;
172
173 size = mode_cmd->pitches[0] * mode_cmd->height;
174 ret = ast_gem_create(dev, size, true, &gobj);
175 if (ret)
176 return ret;
177
178 *gobj_p = gobj;
179 return ret;
180 }
181
astfb_create(struct drm_fb_helper * helper,struct drm_fb_helper_surface_size * sizes)182 static int astfb_create(struct drm_fb_helper *helper,
183 struct drm_fb_helper_surface_size *sizes)
184 {
185 struct ast_fbdev *afbdev =
186 container_of(helper, struct ast_fbdev, helper);
187 struct drm_device *dev = afbdev->helper.dev;
188 struct drm_mode_fb_cmd2 mode_cmd;
189 struct drm_framebuffer *fb;
190 struct fb_info *info;
191 int size, ret;
192 void *sysram;
193 struct drm_gem_object *gobj = NULL;
194 struct ast_bo *bo = NULL;
195 mode_cmd.width = sizes->surface_width;
196 mode_cmd.height = sizes->surface_height;
197 mode_cmd.pitches[0] = mode_cmd.width * ((sizes->surface_bpp + 7)/8);
198
199 mode_cmd.pixel_format = drm_mode_legacy_fb_format(sizes->surface_bpp,
200 sizes->surface_depth);
201
202 size = mode_cmd.pitches[0] * mode_cmd.height;
203
204 ret = astfb_create_object(afbdev, &mode_cmd, &gobj);
205 if (ret) {
206 DRM_ERROR("failed to create fbcon backing object %d\n", ret);
207 return ret;
208 }
209 bo = gem_to_ast_bo(gobj);
210
211 sysram = vmalloc(size);
212 if (!sysram)
213 return -ENOMEM;
214
215 info = drm_fb_helper_alloc_fbi(helper);
216 if (IS_ERR(info)) {
217 ret = PTR_ERR(info);
218 goto out;
219 }
220 info->par = afbdev;
221
222 ret = ast_framebuffer_init(dev, &afbdev->afb, &mode_cmd, gobj);
223 if (ret)
224 goto out;
225
226 afbdev->sysram = sysram;
227 afbdev->size = size;
228
229 fb = &afbdev->afb.base;
230 afbdev->helper.fb = fb;
231
232 strcpy(info->fix.id, "astdrmfb");
233
234 info->fbops = &astfb_ops;
235
236 info->apertures->ranges[0].base = pci_resource_start(dev->pdev, 0);
237 info->apertures->ranges[0].size = pci_resource_len(dev->pdev, 0);
238
239 drm_fb_helper_fill_fix(info, fb->pitches[0], fb->format->depth);
240 drm_fb_helper_fill_var(info, &afbdev->helper, sizes->fb_width, sizes->fb_height);
241
242 info->screen_base = sysram;
243 info->screen_size = size;
244
245 info->pixmap.flags = FB_PIXMAP_SYSTEM;
246
247 DRM_DEBUG_KMS("allocated %dx%d\n",
248 fb->width, fb->height);
249
250 return 0;
251
252 out:
253 vfree(sysram);
254 return ret;
255 }
256
257 static const struct drm_fb_helper_funcs ast_fb_helper_funcs = {
258 .fb_probe = astfb_create,
259 };
260
ast_fbdev_destroy(struct drm_device * dev,struct ast_fbdev * afbdev)261 static void ast_fbdev_destroy(struct drm_device *dev,
262 struct ast_fbdev *afbdev)
263 {
264 struct ast_framebuffer *afb = &afbdev->afb;
265
266 drm_crtc_force_disable_all(dev);
267 drm_fb_helper_unregister_fbi(&afbdev->helper);
268
269 if (afb->obj) {
270 drm_gem_object_put_unlocked(afb->obj);
271 afb->obj = NULL;
272 }
273 drm_fb_helper_fini(&afbdev->helper);
274
275 vfree(afbdev->sysram);
276 drm_framebuffer_unregister_private(&afb->base);
277 drm_framebuffer_cleanup(&afb->base);
278 }
279
ast_fbdev_init(struct drm_device * dev)280 int ast_fbdev_init(struct drm_device *dev)
281 {
282 struct ast_private *ast = dev->dev_private;
283 struct ast_fbdev *afbdev;
284 int ret;
285
286 afbdev = kzalloc(sizeof(struct ast_fbdev), GFP_KERNEL);
287 if (!afbdev)
288 return -ENOMEM;
289
290 ast->fbdev = afbdev;
291 spin_lock_init(&afbdev->dirty_lock);
292
293 drm_fb_helper_prepare(dev, &afbdev->helper, &ast_fb_helper_funcs);
294
295 ret = drm_fb_helper_init(dev, &afbdev->helper, 1);
296 if (ret)
297 goto free;
298
299 ret = drm_fb_helper_single_add_all_connectors(&afbdev->helper);
300 if (ret)
301 goto fini;
302
303 /* disable all the possible outputs/crtcs before entering KMS mode */
304 drm_helper_disable_unused_functions(dev);
305
306 ret = drm_fb_helper_initial_config(&afbdev->helper, 32);
307 if (ret)
308 goto fini;
309
310 return 0;
311
312 fini:
313 drm_fb_helper_fini(&afbdev->helper);
314 free:
315 kfree(afbdev);
316 return ret;
317 }
318
ast_fbdev_fini(struct drm_device * dev)319 void ast_fbdev_fini(struct drm_device *dev)
320 {
321 struct ast_private *ast = dev->dev_private;
322
323 if (!ast->fbdev)
324 return;
325
326 ast_fbdev_destroy(dev, ast->fbdev);
327 kfree(ast->fbdev);
328 ast->fbdev = NULL;
329 }
330
ast_fbdev_set_suspend(struct drm_device * dev,int state)331 void ast_fbdev_set_suspend(struct drm_device *dev, int state)
332 {
333 struct ast_private *ast = dev->dev_private;
334
335 if (!ast->fbdev)
336 return;
337
338 drm_fb_helper_set_suspend(&ast->fbdev->helper, state);
339 }
340
ast_fbdev_set_base(struct ast_private * ast,unsigned long gpu_addr)341 void ast_fbdev_set_base(struct ast_private *ast, unsigned long gpu_addr)
342 {
343 ast->fbdev->helper.fbdev->fix.smem_start =
344 ast->fbdev->helper.fbdev->apertures->ranges[0].base + gpu_addr;
345 ast->fbdev->helper.fbdev->fix.smem_len = ast->vram_size - gpu_addr;
346 }
347