// SPDX-License-Identifier: GPL-2.0 or MIT/* * Copyright (c) 2023 Red Hat. * Author: Jocelyn Falempe <jfalempe@redhat.com> * inspired by the drm_log driver from David Herrmann <dh.herrmann@gmail.com> * Tux Ascii art taken from cowsay written by Tony Monroe */ #include <linux/font.h>#include <linux/init.h>#include <linux/iosys-map.h>#include <linux/kdebug.h>#include <linux/kmsg_dump.h>#include <linux/linux_logo.h>#include <linux/list.h>#include <linux/math.h>#include <linux/module.h>#include <linux/overflow.h>#include <linux/printk.h>#include <linux/types.h>#include <linux/utsname.h>#include <linux/zlib.h> #include <drm/drm_drv.h>#include <drm/drm_fourcc.h>#include <drm/drm_framebuffer.h>#include <drm/drm_modeset_helper_vtables.h>#include <drm/drm_panic.h>#include <drm/drm_plane.h>#include <drm/drm_print.h>#include <drm/drm_rect.h> #include "drm_crtc_internal.h" MODULE_AUTHOR("Jocelyn Falempe");MODULE_DESCRIPTION("DRM panic handler");MODULE_LICENSE("GPL"); static char drm_panic_screen[16] = CONFIG_DRM_PANIC_SCREEN;module_param_string(panic_screen, drm_panic_screen, sizeof(drm_panic_screen), 0644);MODULE_PARM_DESC(panic_screen, "Choose what will be displayed by drm_panic, 'user' or 'kmsg' [default=" CONFIG_DRM_PANIC_SCREEN "]"); /** * DOC: overview * * To enable DRM panic for a driver, the primary plane must implement a * &drm_plane_helper_funcs.get_scanout_buffer helper function. It is then * automatically registered to the drm panic handler. * When a panic occurs, the &drm_plane_helper_funcs.get_scanout_buffer will be * called, and the driver can provide a framebuffer so the panic handler can * draw the panic screen on it. Currently only linear buffer and a few color * formats are supported. * Optionally the driver can also provide a &drm_plane_helper_funcs.panic_flush * callback, that will be called after that, to send additional commands to the * hardware to make the scanout buffer visible. */ /* * This module displays a user friendly message on screen when a kernel panic * occurs. This is conflicting with fbcon, so you can only enable it when fbcon * is disabled. * It's intended for end-user, so have minimal technical/debug information. * * Implementation details: * * It is a panic handler, so it can't take lock, allocate memory, run tasks/irq, * or attempt to sleep. It's a best effort, and it may not be able to display * the message in all situations (like if the panic occurs in the middle of a * modesetting). * It will display only one static frame, so performance optimizations are low * priority as the machine is already in an unusable state. */ struct drm_panic_line { u32 len; const char *txt;}; #define PANIC_LINE(s) {.len = sizeof(s) - 1, .txt = s} static struct drm_panic_line panic_msg[] = { PANIC_LINE("KERNEL PANIC!"), PANIC_LINE(""), PANIC_LINE("Please reboot your computer."), PANIC_LINE(""), PANIC_LINE(""), /* will be replaced by the panic description */}; static const size_t panic_msg_lines = ARRAY_SIZE(panic_msg); static const struct drm_panic_line logo_ascii[] = { PANIC_LINE(" .--. _"), PANIC_LINE(" |o_o | | |"), PANIC_LINE(" |:_/ | | |"), PANIC_LINE(" // \\ \\ |_|"), PANIC_LINE(" (| | ) _"), PANIC_LINE(" /'\\_ _/`\\ (_)"), PANIC_LINE(" \\___)=(___/"),}; static const size_t logo_ascii_lines = ARRAY_SIZE(logo_ascii); #if defined(CONFIG_LOGO) && !defined(MODULE)static const struct linux_logo *logo_mono; static int drm_panic_setup_logo(void){ const struct linux_logo *logo = fb_find_logo(1); const unsigned char *logo_data; struct linux_logo *logo_dup; if (!logo || logo->type != LINUX_LOGO_MONO) return 0; /* The logo is __init, so we must make a copy for later use */ logo_data = kmemdup(logo->data, size_mul(DIV_ROUND_UP(logo->width, BITS_PER_BYTE), logo->height), GFP_KERNEL); if (!logo_data) return -ENOMEM; logo_dup = kmemdup(logo, sizeof(*logo), GFP_KERNEL); if (!logo_dup) { kfree(logo_data); return -ENOMEM; } logo_dup->data = logo_data; logo_mono = logo_dup; return 0;} device_initcall(drm_panic_setup_logo);#else#define logo_mono ((const struct linux_logo *)NULL)#endif /* * Color conversion */ static u16 convert_xrgb8888_to_rgb565(u32 pix){ return ((pix & 0x00F80000) >> 8) | ((pix & 0x0000FC00) >> 5) | ((pix & 0x000000F8) >> 3);} static u16 convert_xrgb8888_to_rgba5551(u32 pix){ return ((pix & 0x00f80000) >> 8) | ((pix & 0x0000f800) >> 5) | ((pix & 0x000000f8) >> 2) | BIT(0); /* set alpha bit */} static u16 convert_xrgb8888_to_xrgb1555(u32 pix){ return ((pix & 0x00f80000) >> 9) | ((pix & 0x0000f800) >> 6) | ((pix & 0x000000f8) >> 3);} static u16 convert_xrgb8888_to_argb1555(u32 pix){ return BIT(15) | /* set alpha bit */ ((pix & 0x00f80000) >> 9) | ((pix & 0x0000f800) >> 6) | ((pix & 0x000000f8) >> 3);} static u32 convert_xrgb8888_to_argb8888(u32 pix){ return pix | GENMASK(31, 24); /* fill alpha bits */} static u32 convert_xrgb8888_to_xbgr8888(u32 pix){ return ((pix & 0x00ff0000) >> 16) << 0 | ((pix & 0x0000ff00) >> 8) << 8 | ((pix & 0x000000ff) >> 0) << 16 | ((pix & 0xff000000) >> 24) << 24;} static u32 convert_xrgb8888_to_abgr8888(u32 pix){ return ((pix & 0x00ff0000) >> 16) << 0 | ((pix & 0x0000ff00) >> 8) << 8 | ((pix & 0x000000ff) >> 0) << 16 | GENMASK(31, 24); /* fill alpha bits */} static u32 convert_xrgb8888_to_xrgb2101010(u32 pix){ pix = ((pix & 0x000000FF) << 2) | ((pix & 0x0000FF00) << 4) | ((pix & 0x00FF0000) << 6); return pix | ((pix >> 8) & 0x00300C03);} static u32 convert_xrgb8888_to_argb2101010(u32 pix){ pix = ((pix & 0x000000FF) << 2) | ((pix & 0x0000FF00) << 4) | ((pix & 0x00FF0000) << 6); return GENMASK(31, 30) /* set alpha bits */ | pix | ((pix >> 8) & 0x00300C03);} static u32 convert_xrgb8888_to_abgr2101010(u32 pix){ pix = ((pix & 0x00FF0000) >> 14) | ((pix & 0x0000FF00) << 4) | ((pix & 0x000000FF) << 22); return GENMASK(31, 30) /* set alpha bits */ | pix | ((pix >> 8) & 0x00300C03);} /* * convert_from_xrgb8888 - convert one pixel from xrgb8888 to the desired format * @color: input color, in xrgb8888 format * @format: output format * * Returns: * Color in the format specified, casted to u32. * Or 0 if the format is not supported. */static u32 convert_from_xrgb8888(u32 color, u32 format){ switch (format) { case DRM_FORMAT_RGB565: return convert_xrgb8888_to_rgb565(color); case DRM_FORMAT_RGBA5551: return convert_xrgb8888_to_rgba5551(color); case DRM_FORMAT_XRGB1555: return convert_xrgb8888_to_xrgb1555(color); case DRM_FORMAT_ARGB1555: return convert_xrgb8888_to_argb1555(color); case DRM_FORMAT_RGB888: case DRM_FORMAT_XRGB8888: return color; case DRM_FORMAT_ARGB8888: return convert_xrgb8888_to_argb8888(color); case DRM_FORMAT_XBGR8888: return convert_xrgb8888_to_xbgr8888(color); case DRM_FORMAT_ABGR8888: return convert_xrgb8888_to_abgr8888(color); case DRM_FORMAT_XRGB2101010: return convert_xrgb8888_to_xrgb2101010(color); case DRM_FORMAT_ARGB2101010: return convert_xrgb8888_to_argb2101010(color); case DRM_FORMAT_ABGR2101010: return convert_xrgb8888_to_abgr2101010(color); default: WARN_ONCE(1, "Can't convert to %p4cc\n", &format); return 0; }} /* * Blit & Fill *//* check if the pixel at coord x,y is 1 (foreground) or 0 (background) */static bool drm_panic_is_pixel_fg(const u8 *sbuf8, unsigned int spitch, int x, int y){ return (sbuf8[(y * spitch) + x / 8] & (0x80 >> (x % 8))) != 0;} static void drm_panic_blit16(struct iosys_map *dmap, unsigned int dpitch, const u8 *sbuf8, unsigned int spitch, unsigned int height, unsigned int width, unsigned int scale, u16 fg16){ unsigned int y, x; for (y = 0; y < height; y++) for (x = 0; x < width; x++) if (drm_panic_is_pixel_fg(sbuf8, spitch, x / scale, y / scale)) iosys_map_wr(dmap, y * dpitch + x * sizeof(u16), u16, fg16);} static void drm_panic_blit24(struct iosys_map *dmap, unsigned int dpitch, const u8 *sbuf8, unsigned int spitch, unsigned int height, unsigned int width, unsigned int scale, u32 fg32){ unsigned int y, x; for (y = 0; y < height; y++) { for (x = 0; x < width; x++) { u32 off = y * dpitch + x * 3; if (drm_panic_is_pixel_fg(sbuf8, spitch, x / scale, y / scale)) { /* write blue-green-red to output in little endianness */ iosys_map_wr(dmap, off, u8, (fg32 & 0x000000FF) >> 0); iosys_map_wr(dmap, off + 1, u8, (fg32 & 0x0000FF00) >> 8); iosys_map_wr(dmap, off + 2, u8, (fg32 & 0x00FF0000) >> 16); } } }} static void drm_panic_blit32(struct iosys_map *dmap, unsigned int dpitch, const u8 *sbuf8, unsigned int spitch, unsigned int height, unsigned int width, unsigned int scale, u32 fg32){ unsigned int y, x; for (y = 0; y < height; y++) for (x = 0; x < width; x++) if (drm_panic_is_pixel_fg(sbuf8, spitch, x / scale, y / scale)) iosys_map_wr(dmap, y * dpitch + x * sizeof(u32), u32, fg32);} static void drm_panic_blit_pixel(struct drm_scanout_buffer *sb, struct drm_rect *clip, const u8 *sbuf8, unsigned int spitch, unsigned int scale, u32 fg_color){ unsigned int y, x; for (y = 0; y < drm_rect_height(clip); y++) for (x = 0; x < drm_rect_width(clip); x++) if (drm_panic_is_pixel_fg(sbuf8, spitch, x / scale, y / scale)) sb->set_pixel(sb, clip->x1 + x, clip->y1 + y, fg_color);} /* * drm_panic_blit - convert a monochrome image to a linear framebuffer * @sb: destination scanout buffer * @clip: destination rectangle * @sbuf8: source buffer, in monochrome format, 8 pixels per byte. * @spitch: source pitch in bytes * @scale: integer scale, source buffer is scale time smaller than destination * rectangle * @fg_color: foreground color, in destination format * * This can be used to draw a font character, which is a monochrome image, to a * framebuffer in other supported format. */static void drm_panic_blit(struct drm_scanout_buffer *sb, struct drm_rect *clip, const u8 *sbuf8, unsigned int spitch, unsigned int scale, u32 fg_color) { struct iosys_map map; if (sb->set_pixel) return drm_panic_blit_pixel(sb, clip, sbuf8, spitch, scale, fg_color); map = sb->map[0]; iosys_map_incr(&map, clip->y1 * sb->pitch[0] + clip->x1 * sb->format->cpp[0]); switch (sb->format->cpp[0]) { case 2: drm_panic_blit16(&map, sb->pitch[0], sbuf8, spitch, drm_rect_height(clip), drm_rect_width(clip), scale, fg_color); break; case 3: drm_panic_blit24(&map, sb->pitch[0], sbuf8, spitch, drm_rect_height(clip), drm_rect_width(clip), scale, fg_color); break; case 4: drm_panic_blit32(&map, sb->pitch[0], sbuf8, spitch, drm_rect_height(clip), drm_rect_width(clip), scale, fg_color); break; default: WARN_ONCE(1, "Can't blit with pixel width %d\n", sb->format->cpp[0]); }} static void drm_panic_fill16(struct iosys_map *dmap, unsigned int dpitch, unsigned int height, unsigned int width, u16 color){ unsigned int y, x; for (y = 0; y < height; y++) for (x = 0; x < width; x++) iosys_map_wr(dmap, y * dpitch + x * sizeof(u16), u16, color);} static void drm_panic_fill24(struct iosys_map *dmap, unsigned int dpitch, unsigned int height, unsigned int width, u32 color){ unsigned int y, x; for (y = 0; y < height; y++) { for (x = 0; x < width; x++) { unsigned int off = y * dpitch + x * 3; /* write blue-green-red to output in little endianness */ iosys_map_wr(dmap, off, u8, (color & 0x000000FF) >> 0); iosys_map_wr(dmap, off + 1, u8, (color & 0x0000FF00) >> 8); iosys_map_wr(dmap, off + 2, u8, (color & 0x00FF0000) >> 16); } }} static void drm_panic_fill32(struct iosys_map *dmap, unsigned int dpitch, unsigned int height, unsigned int width, u32 color){ unsigned int y, x; for (y = 0; y < height; y++) for (x = 0; x < width; x++) iosys_map_wr(dmap, y * dpitch + x * sizeof(u32), u32, color);} static void drm_panic_fill_pixel(struct drm_scanout_buffer *sb, struct drm_rect *clip, u32 color){ unsigned int y, x; for (y = 0; y < drm_rect_height(clip); y++) for (x = 0; x < drm_rect_width(clip); x++) sb->set_pixel(sb, clip->x1 + x, clip->y1 + y, color);} /* * drm_panic_fill - Fill a rectangle with a color * @sb: destination scanout buffer * @clip: destination rectangle * @color: foreground color, in destination format * * Fill a rectangle with a color, in a linear framebuffer. */static void drm_panic_fill(struct drm_scanout_buffer *sb, struct drm_rect *clip, u32 color){ struct iosys_map map; if (sb->set_pixel) return drm_panic_fill_pixel(sb, clip, color); map = sb->map[0]; iosys_map_incr(&map, clip->y1 * sb->pitch[0] + clip->x1 * sb->format->cpp[0]); switch (sb->format->cpp[0]) { case 2: drm_panic_fill16(&map, sb->pitch[0], drm_rect_height(clip), drm_rect_width(clip), color); break; case 3: drm_panic_fill24(&map, sb->pitch[0], drm_rect_height(clip), drm_rect_width(clip), color); break; case 4: drm_panic_fill32(&map, sb->pitch[0], drm_rect_height(clip), drm_rect_width(clip), color); break; default: WARN_ONCE(1, "Can't fill with pixel width %d\n", sb->format->cpp[0]); }} static const u8 *get_char_bitmap(const struct font_desc *font, char c, size_t font_pitch){ return font->data + (c * font->height) * font_pitch;} static unsigned int get_max_line_len(const struct drm_panic_line *lines, int len){ int i; unsigned int max = 0; for (i = 0; i < len; i++) max = max(lines[i].len, max); return max;} /* * Draw a text in a rectangle on a framebuffer. The text is truncated if it overflows the rectangle */static void draw_txt_rectangle(struct drm_scanout_buffer *sb, const struct font_desc *font, const struct drm_panic_line *msg, unsigned int msg_lines, bool centered, struct drm_rect *clip, u32 color){ int i, j; const u8 *src; size_t font_pitch = DIV_ROUND_UP(font->width, 8); struct drm_rect rec; msg_lines = min(msg_lines, drm_rect_height(clip) / font->height); for (i = 0; i < msg_lines; i++) { size_t line_len = min(msg[i].len, drm_rect_width(clip) / font->width); rec.y1 = clip->y1 + i * font->height; rec.y2 = rec.y1 + font->height; rec.x1 = clip->x1; if (centered)Lines 1–500 of 1074. Load more
// SPDX-License-Identifier: GPL-2.0 or MIT /* * Copyright (c) 2023 Red Hat. * Author: Jocelyn Falempe <jfalempe@redhat.com> * inspired by the drm_log driver from David Herrmann <dh.herrmann@gmail.com> * Tux Ascii art taken from cowsay written by Tony Monroe */ #include <linux/font.h> #include <linux/init.h> #include <linux/iosys-map.h> #include <linux/kdebug.h> #include <linux/kmsg_dump.h> #include <linux/linux_logo.h> #include <linux/list.h> #include <linux/math.h> #include <linux/module.h> #include <linux/overflow.h> #include <linux/printk.h> #include <linux/types.h> #include <linux/utsname.h> #include <linux/zlib.h> #include <drm/drm_drv.h> #include <drm/drm_fourcc.h> #include <drm/drm_framebuffer.h> #include <drm/drm_modeset_helper_vtables.h> #include <drm/drm_panic.h> #include <drm/drm_plane.h> #include <drm/drm_print.h> #include <drm/drm_rect.h> #include "drm_crtc_internal.h" MODULE_AUTHOR("Jocelyn Falempe"); MODULE_DESCRIPTION("DRM panic handler"); MODULE_LICENSE("GPL"); static char drm_panic_screen[16] = CONFIG_DRM_PANIC_SCREEN; module_param_string(panic_screen, drm_panic_screen, sizeof(drm_panic_screen), 0644); MODULE_PARM_DESC(panic_screen, "Choose what will be displayed by drm_panic, 'user' or 'kmsg' [default=" CONFIG_DRM_PANIC_SCREEN "]"); /** * DOC: overview * * To enable DRM panic for a driver, the primary plane must implement a * &drm_plane_helper_funcs.get_scanout_buffer helper function. It is then * automatically registered to the drm panic handler. * When a panic occurs, the &drm_plane_helper_funcs.get_scanout_buffer will be * called, and the driver can provide a framebuffer so the panic handler can * draw the panic screen on it. Currently only linear buffer and a few color * formats are supported. * Optionally the driver can also provide a &drm_plane_helper_funcs.panic_flush * callback, that will be called after that, to send additional commands to the * hardware to make the scanout buffer visible. */ /* * This module displays a user friendly message on screen when a kernel panic * occurs. This is conflicting with fbcon, so you can only enable it when fbcon * is disabled. * It's intended for end-user, so have minimal technical/debug information. * * Implementation details: * * It is a panic handler, so it can't take lock, allocate memory, run tasks/irq, * or attempt to sleep. It's a best effort, and it may not be able to display * the message in all situations (like if the panic occurs in the middle of a * modesetting). * It will display only one static frame, so performance optimizations are low * priority as the machine is already in an unusable state. */ struct drm_panic_line { u32 len; const char *txt; }; #define PANIC_LINE(s) {.len = sizeof(s) - 1, .txt = s} static struct drm_panic_line panic_msg[] = { PANIC_LINE("KERNEL PANIC!"), PANIC_LINE(""), PANIC_LINE("Please reboot your computer."), PANIC_LINE(""), PANIC_LINE(""), /* will be replaced by the panic description */ }; static const size_t panic_msg_lines = ARRAY_SIZE(panic_msg); static const struct drm_panic_line logo_ascii[] = { PANIC_LINE(" .--. _"), PANIC_LINE(" |o_o | | |"), PANIC_LINE(" |:_/ | | |"), PANIC_LINE(" // \\ \\ |_|"), PANIC_LINE(" (| | ) _"), PANIC_LINE(" /'\\_ _/`\\ (_)"), PANIC_LINE(" \\___)=(___/"), }; static const size_t logo_ascii_lines = ARRAY_SIZE(logo_ascii); #if defined(CONFIG_LOGO) && !defined(MODULE) static const struct linux_logo *logo_mono; static int drm_panic_setup_logo(void) { const struct linux_logo *logo = fb_find_logo(1); const unsigned char *logo_data; struct linux_logo *logo_dup; if (!logo || logo->type != LINUX_LOGO_MONO) return 0; /* The logo is __init, so we must make a copy for later use */ logo_data = kmemdup(logo->data, size_mul(DIV_ROUND_UP(logo->width, BITS_PER_BYTE), logo->height), GFP_KERNEL); if (!logo_data) return -ENOMEM; logo_dup = kmemdup(logo, sizeof(*logo), GFP_KERNEL); if (!logo_dup) { kfree(logo_data); return -ENOMEM; } logo_dup->data = logo_data; logo_mono = logo_dup; return 0; } device_initcall(drm_panic_setup_logo); #else #define logo_mono ((const struct linux_logo *)NULL) #endif /* * Color conversion */ static u16 convert_xrgb8888_to_rgb565(u32 pix) { return ((pix & 0x00F80000) >> 8) | ((pix & 0x0000FC00) >> 5) | ((pix & 0x000000F8) >> 3); } static u16 convert_xrgb8888_to_rgba5551(u32 pix) { return ((pix & 0x00f80000) >> 8) | ((pix & 0x0000f800) >> 5) | ((pix & 0x000000f8) >> 2) | BIT(0); /* set alpha bit */ } static u16 convert_xrgb8888_to_xrgb1555(u32 pix) { return ((pix & 0x00f80000) >> 9) | ((pix & 0x0000f800) >> 6) | ((pix & 0x000000f8) >> 3); } static u16 convert_xrgb8888_to_argb1555(u32 pix) { return BIT(15) | /* set alpha bit */ ((pix & 0x00f80000) >> 9) | ((pix & 0x0000f800) >> 6) | ((pix & 0x000000f8) >> 3); } static u32 convert_xrgb8888_to_argb8888(u32 pix) { return pix | GENMASK(31, 24); /* fill alpha bits */ } static u32 convert_xrgb8888_to_xbgr8888(u32 pix) { return ((pix & 0x00ff0000) >> 16) << 0 | ((pix & 0x0000ff00) >> 8) << 8 | ((pix & 0x000000ff) >> 0) << 16 | ((pix & 0xff000000) >> 24) << 24; } static u32 convert_xrgb8888_to_abgr8888(u32 pix) { return ((pix & 0x00ff0000) >> 16) << 0 | ((pix & 0x0000ff00) >> 8) << 8 | ((pix & 0x000000ff) >> 0) << 16 | GENMASK(31, 24); /* fill alpha bits */ } static u32 convert_xrgb8888_to_xrgb2101010(u32 pix) { pix = ((pix & 0x000000FF) << 2) | ((pix & 0x0000FF00) << 4) | ((pix & 0x00FF0000) << 6); return pix | ((pix >> 8) & 0x00300C03); } static u32 convert_xrgb8888_to_argb2101010(u32 pix) { pix = ((pix & 0x000000FF) << 2) | ((pix & 0x0000FF00) << 4) | ((pix & 0x00FF0000) << 6); return GENMASK(31, 30) /* set alpha bits */ | pix | ((pix >> 8) & 0x00300C03); } static u32 convert_xrgb8888_to_abgr2101010(u32 pix) { pix = ((pix & 0x00FF0000) >> 14) | ((pix & 0x0000FF00) << 4) | ((pix & 0x000000FF) << 22); return GENMASK(31, 30) /* set alpha bits */ | pix | ((pix >> 8) & 0x00300C03); } /* * convert_from_xrgb8888 - convert one pixel from xrgb8888 to the desired format * @color: input color, in xrgb8888 format * @format: output format * * Returns: * Color in the format specified, casted to u32. * Or 0 if the format is not supported. */ static u32 convert_from_xrgb8888(u32 color, u32 format) { switch (format) { case DRM_FORMAT_RGB565: return convert_xrgb8888_to_rgb565(color); case DRM_FORMAT_RGBA5551: return convert_xrgb8888_to_rgba5551(color); case DRM_FORMAT_XRGB1555: return convert_xrgb8888_to_xrgb1555(color); case DRM_FORMAT_ARGB1555: return convert_xrgb8888_to_argb1555(color); case DRM_FORMAT_RGB888: case DRM_FORMAT_XRGB8888: return color; case DRM_FORMAT_ARGB8888: return convert_xrgb8888_to_argb8888(color); case DRM_FORMAT_XBGR8888: return convert_xrgb8888_to_xbgr8888(color); case DRM_FORMAT_ABGR8888: return convert_xrgb8888_to_abgr8888(color); case DRM_FORMAT_XRGB2101010: return convert_xrgb8888_to_xrgb2101010(color); case DRM_FORMAT_ARGB2101010: return convert_xrgb8888_to_argb2101010(color); case DRM_FORMAT_ABGR2101010: return convert_xrgb8888_to_abgr2101010(color); default: WARN_ONCE(1, "Can't convert to %p4cc\n", &format); return 0; } } /* * Blit & Fill */ /* check if the pixel at coord x,y is 1 (foreground) or 0 (background) */ static bool drm_panic_is_pixel_fg(const u8 *sbuf8, unsigned int spitch, int x, int y) { return (sbuf8[(y * spitch) + x / 8] & (0x80 >> (x % 8))) != 0; } static void drm_panic_blit16(struct iosys_map *dmap, unsigned int dpitch, const u8 *sbuf8, unsigned int spitch, unsigned int height, unsigned int width, unsigned int scale, u16 fg16) { unsigned int y, x; for (y = 0; y < height; y++) for (x = 0; x < width; x++) if (drm_panic_is_pixel_fg(sbuf8, spitch, x / scale, y / scale)) iosys_map_wr(dmap, y * dpitch + x * sizeof(u16), u16, fg16); } static void drm_panic_blit24(struct iosys_map *dmap, unsigned int dpitch, const u8 *sbuf8, unsigned int spitch, unsigned int height, unsigned int width, unsigned int scale, u32 fg32) { unsigned int y, x; for (y = 0; y < height; y++) { for (x = 0; x < width; x++) { u32 off = y * dpitch + x * 3; if (drm_panic_is_pixel_fg(sbuf8, spitch, x / scale, y / scale)) { /* write blue-green-red to output in little endianness */ iosys_map_wr(dmap, off, u8, (fg32 & 0x000000FF) >> 0); iosys_map_wr(dmap, off + 1, u8, (fg32 & 0x0000FF00) >> 8); iosys_map_wr(dmap, off + 2, u8, (fg32 & 0x00FF0000) >> 16); } } } } static void drm_panic_blit32(struct iosys_map *dmap, unsigned int dpitch, const u8 *sbuf8, unsigned int spitch, unsigned int height, unsigned int width, unsigned int scale, u32 fg32) { unsigned int y, x; for (y = 0; y < height; y++) for (x = 0; x < width; x++) if (drm_panic_is_pixel_fg(sbuf8, spitch, x / scale, y / scale)) iosys_map_wr(dmap, y * dpitch + x * sizeof(u32), u32, fg32); } static void drm_panic_blit_pixel(struct drm_scanout_buffer *sb, struct drm_rect *clip, const u8 *sbuf8, unsigned int spitch, unsigned int scale, u32 fg_color) { unsigned int y, x; for (y = 0; y < drm_rect_height(clip); y++) for (x = 0; x < drm_rect_width(clip); x++) if (drm_panic_is_pixel_fg(sbuf8, spitch, x / scale, y / scale)) sb->set_pixel(sb, clip->x1 + x, clip->y1 + y, fg_color); } /* * drm_panic_blit - convert a monochrome image to a linear framebuffer * @sb: destination scanout buffer * @clip: destination rectangle * @sbuf8: source buffer, in monochrome format, 8 pixels per byte. * @spitch: source pitch in bytes * @scale: integer scale, source buffer is scale time smaller than destination * rectangle * @fg_color: foreground color, in destination format * * This can be used to draw a font character, which is a monochrome image, to a * framebuffer in other supported format. */ static void drm_panic_blit(struct drm_scanout_buffer *sb, struct drm_rect *clip, const u8 *sbuf8, unsigned int spitch, unsigned int scale, u32 fg_color) { struct iosys_map map; if (sb->set_pixel) return drm_panic_blit_pixel(sb, clip, sbuf8, spitch, scale, fg_color); map = sb->map[0]; iosys_map_incr(&map, clip->y1 * sb->pitch[0] + clip->x1 * sb->format->cpp[0]); switch (sb->format->cpp[0]) { case 2: drm_panic_blit16(&map, sb->pitch[0], sbuf8, spitch, drm_rect_height(clip), drm_rect_width(clip), scale, fg_color); break; case 3: drm_panic_blit24(&map, sb->pitch[0], sbuf8, spitch, drm_rect_height(clip), drm_rect_width(clip), scale, fg_color); break; case 4: drm_panic_blit32(&map, sb->pitch[0], sbuf8, spitch, drm_rect_height(clip), drm_rect_width(clip), scale, fg_color); break; default: WARN_ONCE(1, "Can't blit with pixel width %d\n", sb->format->cpp[0]); } } static void drm_panic_fill16(struct iosys_map *dmap, unsigned int dpitch, unsigned int height, unsigned int width, u16 color) { unsigned int y, x; for (y = 0; y < height; y++) for (x = 0; x < width; x++) iosys_map_wr(dmap, y * dpitch + x * sizeof(u16), u16, color); } static void drm_panic_fill24(struct iosys_map *dmap, unsigned int dpitch, unsigned int height, unsigned int width, u32 color) { unsigned int y, x; for (y = 0; y < height; y++) { for (x = 0; x < width; x++) { unsigned int off = y * dpitch + x * 3; /* write blue-green-red to output in little endianness */ iosys_map_wr(dmap, off, u8, (color & 0x000000FF) >> 0); iosys_map_wr(dmap, off + 1, u8, (color & 0x0000FF00) >> 8); iosys_map_wr(dmap, off + 2, u8, (color & 0x00FF0000) >> 16); } } } static void drm_panic_fill32(struct iosys_map *dmap, unsigned int dpitch, unsigned int height, unsigned int width, u32 color) { unsigned int y, x; for (y = 0; y < height; y++) for (x = 0; x < width; x++) iosys_map_wr(dmap, y * dpitch + x * sizeof(u32), u32, color); } static void drm_panic_fill_pixel(struct drm_scanout_buffer *sb, struct drm_rect *clip, u32 color) { unsigned int y, x; for (y = 0; y < drm_rect_height(clip); y++) for (x = 0; x < drm_rect_width(clip); x++) sb->set_pixel(sb, clip->x1 + x, clip->y1 + y, color); } /* * drm_panic_fill - Fill a rectangle with a color * @sb: destination scanout buffer * @clip: destination rectangle * @color: foreground color, in destination format * * Fill a rectangle with a color, in a linear framebuffer. */ static void drm_panic_fill(struct drm_scanout_buffer *sb, struct drm_rect *clip, u32 color) { struct iosys_map map; if (sb->set_pixel) return drm_panic_fill_pixel(sb, clip, color); map = sb->map[0]; iosys_map_incr(&map, clip->y1 * sb->pitch[0] + clip->x1 * sb->format->cpp[0]); switch (sb->format->cpp[0]) { case 2: drm_panic_fill16(&map, sb->pitch[0], drm_rect_height(clip), drm_rect_width(clip), color); break; case 3: drm_panic_fill24(&map, sb->pitch[0], drm_rect_height(clip), drm_rect_width(clip), color); break; case 4: drm_panic_fill32(&map, sb->pitch[0], drm_rect_height(clip), drm_rect_width(clip), color); break; default: WARN_ONCE(1, "Can't fill with pixel width %d\n", sb->format->cpp[0]); } } static const u8 *get_char_bitmap(const struct font_desc *font, char c, size_t font_pitch) { return font->data + (c * font->height) * font_pitch; } static unsigned int get_max_line_len(const struct drm_panic_line *lines, int len) { int i; unsigned int max = 0; for (i = 0; i < len; i++) max = max(lines[i].len, max); return max; } /* * Draw a text in a rectangle on a framebuffer. The text is truncated if it overflows the rectangle */ static void draw_txt_rectangle(struct drm_scanout_buffer *sb, const struct font_desc *font, const struct drm_panic_line *msg, unsigned int msg_lines, bool centered, struct drm_rect *clip, u32 color) { int i, j; const u8 *src; size_t font_pitch = DIV_ROUND_UP(font->width, 8); struct drm_rect rec; msg_lines = min(msg_lines, drm_rect_height(clip) / font->height); for (i = 0; i < msg_lines; i++) { size_t line_len = min(msg[i].len, drm_rect_width(clip) / font->width); rec.y1 = clip->y1 + i * font->height; rec.y2 = rec.y1 + font->height; rec.x1 = clip->x1; if (centered)