diff options
author | Antonino A. Daplas <adaplas@gmail.com> | 2005-11-07 04:00:39 -0500 |
---|---|---|
committer | Linus Torvalds <torvalds@g5.osdl.org> | 2005-11-07 10:53:51 -0500 |
commit | b4d8aea6d66aabc1d79aaeb1ecc90562abb8f575 (patch) | |
tree | 9d1acb46481ba54827463ae2d8f79821d5119953 /drivers | |
parent | dd0314f7bb407bc4bdb3ea769b9c8a3a5d39ffd7 (diff) |
[PATCH] fbdev: Remove software clipping from drawing functions
Remove software clipping from imageblit, fillrect and copyarea. Clipping is
not needed because the console layer assures that reads/writes doest not
happen beyond the extents of the framebuffer. And software clipping tends to
hide bugs, if they do exist.
Signed-off-by: Antonino Daplas <adaplas@pol.net>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Diffstat (limited to 'drivers')
-rw-r--r-- | drivers/video/cfbcopyarea.c | 36 | ||||
-rw-r--r-- | drivers/video/cfbfillrect.c | 24 | ||||
-rw-r--r-- | drivers/video/cfbimgblt.c | 22 |
3 files changed, 3 insertions, 79 deletions
diff --git a/drivers/video/cfbcopyarea.c b/drivers/video/cfbcopyarea.c index 67711f7b11b1..cdc71572cf35 100644 --- a/drivers/video/cfbcopyarea.c +++ b/drivers/video/cfbcopyarea.c | |||
@@ -349,46 +349,10 @@ void cfb_copyarea(struct fb_info *p, const struct fb_copyarea *area) | |||
349 | unsigned long __iomem *dst = NULL, *src = NULL; | 349 | unsigned long __iomem *dst = NULL, *src = NULL; |
350 | int bits = BITS_PER_LONG, bytes = bits >> 3; | 350 | int bits = BITS_PER_LONG, bytes = bits >> 3; |
351 | int dst_idx = 0, src_idx = 0, rev_copy = 0; | 351 | int dst_idx = 0, src_idx = 0, rev_copy = 0; |
352 | int x2, y2, vxres, vyres; | ||
353 | 352 | ||
354 | if (p->state != FBINFO_STATE_RUNNING) | 353 | if (p->state != FBINFO_STATE_RUNNING) |
355 | return; | 354 | return; |
356 | 355 | ||
357 | /* We want rotation but lack hardware to do it for us. */ | ||
358 | if (!p->fbops->fb_rotate && p->var.rotate) { | ||
359 | } | ||
360 | |||
361 | vxres = p->var.xres_virtual; | ||
362 | vyres = p->var.yres_virtual; | ||
363 | |||
364 | if (area->dx > vxres || area->sx > vxres || | ||
365 | area->dy > vyres || area->sy > vyres) | ||
366 | return; | ||
367 | |||
368 | /* clip the destination | ||
369 | * We could use hardware clipping but on many cards you get around | ||
370 | * hardware clipping by writing to framebuffer directly. | ||
371 | */ | ||
372 | x2 = area->dx + area->width; | ||
373 | y2 = area->dy + area->height; | ||
374 | dx = area->dx > 0 ? area->dx : 0; | ||
375 | dy = area->dy > 0 ? area->dy : 0; | ||
376 | x2 = x2 < vxres ? x2 : vxres; | ||
377 | y2 = y2 < vyres ? y2 : vyres; | ||
378 | width = x2 - dx; | ||
379 | height = y2 - dy; | ||
380 | |||
381 | if ((width==0) ||(height==0)) | ||
382 | return; | ||
383 | |||
384 | /* update sx1,sy1 */ | ||
385 | sx += (dx - area->dx); | ||
386 | sy += (dy - area->dy); | ||
387 | |||
388 | /* the source must be completely inside the virtual screen */ | ||
389 | if (sx < 0 || sy < 0 || (sx + width) > vxres || (sy + height) > vyres) | ||
390 | return; | ||
391 | |||
392 | /* if the beginning of the target area might overlap with the end of | 356 | /* if the beginning of the target area might overlap with the end of |
393 | the source area, be have to copy the area reverse. */ | 357 | the source area, be have to copy the area reverse. */ |
394 | if ((dy == sy && dx > sx) || (dy > sy)) { | 358 | if ((dy == sy && dx > sx) || (dy > sy)) { |
diff --git a/drivers/video/cfbfillrect.c b/drivers/video/cfbfillrect.c index e4fc42b013eb..167d9314e6eb 100644 --- a/drivers/video/cfbfillrect.c +++ b/drivers/video/cfbfillrect.c | |||
@@ -344,7 +344,8 @@ bitfill_unaligned_rev(unsigned long __iomem *dst, int dst_idx, unsigned long pat | |||
344 | 344 | ||
345 | void cfb_fillrect(struct fb_info *p, const struct fb_fillrect *rect) | 345 | void cfb_fillrect(struct fb_info *p, const struct fb_fillrect *rect) |
346 | { | 346 | { |
347 | unsigned long x2, y2, vxres, vyres, height, width, pat, fg; | 347 | unsigned long pat, fg; |
348 | unsigned long width = rect->width, height = rect->height; | ||
348 | int bits = BITS_PER_LONG, bytes = bits >> 3; | 349 | int bits = BITS_PER_LONG, bytes = bits >> 3; |
349 | u32 bpp = p->var.bits_per_pixel; | 350 | u32 bpp = p->var.bits_per_pixel; |
350 | unsigned long __iomem *dst; | 351 | unsigned long __iomem *dst; |
@@ -353,27 +354,6 @@ void cfb_fillrect(struct fb_info *p, const struct fb_fillrect *rect) | |||
353 | if (p->state != FBINFO_STATE_RUNNING) | 354 | if (p->state != FBINFO_STATE_RUNNING) |
354 | return; | 355 | return; |
355 | 356 | ||
356 | /* We want rotation but lack hardware to do it for us. */ | ||
357 | if (!p->fbops->fb_rotate && p->var.rotate) { | ||
358 | } | ||
359 | |||
360 | vxres = p->var.xres_virtual; | ||
361 | vyres = p->var.yres_virtual; | ||
362 | |||
363 | if (!rect->width || !rect->height || | ||
364 | rect->dx > vxres || rect->dy > vyres) | ||
365 | return; | ||
366 | |||
367 | /* We could use hardware clipping but on many cards you get around | ||
368 | * hardware clipping by writing to framebuffer directly. */ | ||
369 | |||
370 | x2 = rect->dx + rect->width; | ||
371 | y2 = rect->dy + rect->height; | ||
372 | x2 = x2 < vxres ? x2 : vxres; | ||
373 | y2 = y2 < vyres ? y2 : vyres; | ||
374 | width = x2 - rect->dx; | ||
375 | height = y2 - rect->dy; | ||
376 | |||
377 | if (p->fix.visual == FB_VISUAL_TRUECOLOR || | 357 | if (p->fix.visual == FB_VISUAL_TRUECOLOR || |
378 | p->fix.visual == FB_VISUAL_DIRECTCOLOR ) | 358 | p->fix.visual == FB_VISUAL_DIRECTCOLOR ) |
379 | fg = ((u32 *) (p->pseudo_palette))[rect->color]; | 359 | fg = ((u32 *) (p->pseudo_palette))[rect->color]; |
diff --git a/drivers/video/cfbimgblt.c b/drivers/video/cfbimgblt.c index 4c123abaa843..da664cea7eca 100644 --- a/drivers/video/cfbimgblt.c +++ b/drivers/video/cfbimgblt.c | |||
@@ -272,33 +272,13 @@ void cfb_imageblit(struct fb_info *p, const struct fb_image *image) | |||
272 | { | 272 | { |
273 | u32 fgcolor, bgcolor, start_index, bitstart, pitch_index = 0; | 273 | u32 fgcolor, bgcolor, start_index, bitstart, pitch_index = 0; |
274 | u32 bpl = sizeof(u32), bpp = p->var.bits_per_pixel; | 274 | u32 bpl = sizeof(u32), bpp = p->var.bits_per_pixel; |
275 | u32 width = image->width, height = image->height; | 275 | u32 width = image->width; |
276 | u32 dx = image->dx, dy = image->dy; | 276 | u32 dx = image->dx, dy = image->dy; |
277 | int x2, y2, vxres, vyres; | ||
278 | u8 __iomem *dst1; | 277 | u8 __iomem *dst1; |
279 | 278 | ||
280 | if (p->state != FBINFO_STATE_RUNNING) | 279 | if (p->state != FBINFO_STATE_RUNNING) |
281 | return; | 280 | return; |
282 | 281 | ||
283 | vxres = p->var.xres_virtual; | ||
284 | vyres = p->var.yres_virtual; | ||
285 | /* | ||
286 | * We could use hardware clipping but on many cards you get around | ||
287 | * hardware clipping by writing to framebuffer directly like we are | ||
288 | * doing here. | ||
289 | */ | ||
290 | if (image->dx > vxres || image->dy > vyres) | ||
291 | return; | ||
292 | |||
293 | x2 = image->dx + image->width; | ||
294 | y2 = image->dy + image->height; | ||
295 | dx = image->dx > 0 ? image->dx : 0; | ||
296 | dy = image->dy > 0 ? image->dy : 0; | ||
297 | x2 = x2 < vxres ? x2 : vxres; | ||
298 | y2 = y2 < vyres ? y2 : vyres; | ||
299 | width = x2 - dx; | ||
300 | height = y2 - dy; | ||
301 | |||
302 | bitstart = (dy * p->fix.line_length * 8) + (dx * bpp); | 282 | bitstart = (dy * p->fix.line_length * 8) + (dx * bpp); |
303 | start_index = bitstart & (32 - 1); | 283 | start_index = bitstart & (32 - 1); |
304 | pitch_index = (p->fix.line_length & (bpl - 1)) * 8; | 284 | pitch_index = (p->fix.line_length & (bpl - 1)) * 8; |