This thread has been locked.

If you have a related question, please click the "Ask a related question" button in the top right corner. The newly created question will be automatically linked to this question.

AM335X fb 测试程序,HDMI 显示屏上无反应

各位老师;

手头的板子是 beagle bone black ,软件是 ti-processor-sdk-linux-am335x-evm-06.00.00.07 ,烧写的程序是官方预编译的内核和uboot,

测试程序是在屏幕上输出3个红绿蓝的方块,在 ubuntu 上测试通过,但是交叉编译后放在板子上运行,屏幕无反应.测试程序如下:

请大神们指教!

#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <fcntl.h>
#include <linux/fb.h>
#include <linux/kd.h>
#include <sys/mman.h>
#include <sys/ioctl.h>
#include <sys/time.h>
#include <string.h>
#include <errno.h>


//用于保存Framebuffer设备的可变信息
struct fb_var_screeninfo vinfo;

//用于保存Framebuffer设备的固定信息
struct fb_fix_screeninfo finfo;
int fbFd = 0;
char *frameBuffer = 0;

void printFixedInfo()
{
printf("Fixed screen info:\n"
"\tid: %s\n"
"\tsmem_start: 0x%lx\n"
"\tsmem_len: %d\n"
"\ttype: %d\n"
"\ttype_aux: %d\n"
"\tvisual: %d\n"
"\txpanstep: %d\n"
"\typanstep: %d\n"
"\tywrapstep: %d\n"
"\tline_length: %d\n"
"\tmmio_start: 0x%lx\n"
"\tmmio_len: %d\n"
"\taccel: %d\n"
"\n",
finfo.id, finfo.smem_start, finfo.smem_len, finfo.type,
finfo.type_aux, finfo.visual, finfo.xpanstep, finfo.ypanstep,
finfo.ywrapstep, finfo.line_length, finfo.mmio_start,
finfo.mmio_len, finfo.accel);
}
void printVariableInfo()
{
printf("Variable screen info:\n"
"\txres: %d\n"
"\tyres: %d\n"
"\txres_virtual: %d\n"
"\tyres_virtual: %d\n"
"\tyoffset: %d\n"
"\txoffset: %d\n"
"\tbits_per_pixel: %d\n"
"\tgrayscale: %d\n"
"\tred: offset: %2d, length: %2d, msb_right: %2d\n"
"\tgreen: offset: %2d, length: %2d, msb_right: %2d\n"
"\tblue: offset: %2d, length: %2d, msb_right: %2d\n"
"\ttransp: offset: %2d, length: %2d, msb_right: %2d\n"
"\tnonstd: %d\n"
"\tactivate: %d\n"
"\theight: %d\n"
"\twidth: %d\n"
"\taccel_flags: 0x%x\n"
"\tpixclock: %d\n"
"\tleft_margin: %d\n"
"\tright_margin: %d\n"
"\tupper_margin: %d\n"
"\tlower_margin: %d\n"
"\thsync_len: %d\n"
"\tvsync_len: %d\n"
"\tsync: %d\n"
"\tvmode: %d\n"
"\n",
vinfo.xres, vinfo.yres, vinfo.xres_virtual, vinfo.yres_virtual,
vinfo.xoffset, vinfo.yoffset, vinfo.bits_per_pixel, vinfo.grayscale,
vinfo.red.offset, vinfo.red.length, vinfo.red.msb_right,
vinfo.green.offset, vinfo.green.length, vinfo.green.msb_right,
vinfo.blue.offset, vinfo.blue.length, vinfo.blue.msb_right,
vinfo.transp.offset, vinfo.transp.length, vinfo.transp.msb_right,
vinfo.nonstd, vinfo.activate, vinfo.height, vinfo.width,
vinfo.accel_flags, vinfo.pixclock, vinfo.left_margin,
vinfo.right_margin, vinfo.upper_margin, vinfo.lower_margin,
vinfo.hsync_len, vinfo.vsync_len, vinfo.sync, vinfo.vmode);
}

#define PERFORMANCE_RUN_COUNT 5
void performSpeedTest(void* fb, int fbSize)
{
int i, j, run;

struct timeval startTime, endTime;
unsigned long long results[PERFORMANCE_RUN_COUNT];
unsigned long long average;

unsigned int* testImage;

unsigned int randData[17] = {
0x3A428472, 0x724B84D3, 0x26B898AB, 0x7D980E3C, 0x5345A084,
0x6779B66B, 0x791EE4B4, 0x6E8EE3CC, 0x63AF504A, 0x18A21B33,
0x0E26EB73, 0x022F708E, 0x1740F3B0, 0x7E2C699D, 0x0E8A570B,
0x5F2C22FB, 0x6A742130
};

printf("Frame Buffer Performance test...\n");

for (run=0; run<PERFORMANCE_RUN_COUNT; ++run) {

/* Generate test image with random(ish) data: */
testImage = (unsigned int*) malloc(fbSize);
j = run;
for (i=0; i < (int)(fbSize / sizeof(int)); ++i) {
testImage[i] = randData[j];
j++;
if (j >= 17)
j = 0;
}

gettimeofday(&startTime, NULL);
memcpy(fb, testImage, fbSize);
gettimeofday(&endTime, NULL);

long secsDiff = endTime.tv_sec - startTime.tv_sec;
results[run] = secsDiff * 1000000 + (endTime.tv_usec - startTime.tv_usec);

free(testImage);
}


average = 0;
for (i=0; i<PERFORMANCE_RUN_COUNT; ++i)
average += results[i];
average = average / PERFORMANCE_RUN_COUNT;

printf(" Average: %llu usecs\n", average);
printf(" Bandwidth: %.03f MByte/Sec\n", (fbSize / 1048576.0) / ((double)average / 1000000.0));
printf(" Max. FPS: %.03f fps\n\n", 1000000.0 / (double)average);

/* Clear the framebuffer back to black again: */
memset(fb, 0, fbSize);
}

void drawRect_rgb32(int x0, int y0, int width, int height, int color)
{
const int bytesPerPixel = 4;
const int stride = finfo.line_length / bytesPerPixel;

int *dest = (int*)(frameBuffer)
+ (y0 + vinfo.yoffset) * stride
+ (x0 + vinfo.xoffset);

int x, y;
for (y = 0; y < height; ++y) {
for (x = 0; x < width; ++x) {
dest[x] = color;
}
dest += stride;
}
}

void drawRect_rgb18(int x0, int y0, int width, int height, int color)
{
const int bytesPerPixel = 3;
const int stride = finfo.line_length - width * bytesPerPixel;
const int red = (color & 0xff0000) >> 16;
const int green = (color & 0xff00) >> 8;
const int blue = (color & 0xff);
const unsigned int packed = (blue >> 2) |
((green >> 2) << 6) |
((red >> 2) << 12);
const char color18[3] = { packed & 0xff,
(packed & 0xff00) >> 8,
(packed & 0xff0000) >> 16 };

char *dest = (char*)(frameBuffer)
+ (y0 + vinfo.yoffset) * stride
+ (x0 + vinfo.xoffset);

int x, y;
for (y = 0; y < height; ++y) {
for (x = 0; x < width; ++x) {
*dest++ = color18[0];
*dest++ = color18[1];
*dest++ = color18[2];
}
dest += stride;
}
}

void drawRect_rgb16(int x0, int y0, int width, int height, int color)
{
const int bytesPerPixel = 2;
const int stride = finfo.line_length / bytesPerPixel;
const int red = (color & 0xff0000) >> (16 + 3);
const int green = (color & 0xff00) >> (8 + 2);
const int blue = (color & 0xff) >> 3;
const short color16 = blue | (green << 5) | (red << (5 + 6));

short *dest = (short*)(frameBuffer)
+ (y0 + vinfo.yoffset) * stride
+ (x0 + vinfo.xoffset);

int x, y;
for (y = 0; y < height; ++y) {
for (x = 0; x < width; ++x) {
dest[x] = color16;
}
dest += stride;
}
}

void drawRect_rgb15(int x0, int y0, int width, int height, int color)
{
const int bytesPerPixel = 2;
const int stride = finfo.line_length / bytesPerPixel;
const int red = (color & 0xff0000) >> (16 + 3);
const int green = (color & 0xff00) >> (8 + 3);
const int blue = (color & 0xff) >> 3;
const short color15 = blue | (green << 5) | (red << (5 + 5));

short *dest = (short*)(frameBuffer)
+ (y0 + vinfo.yoffset) * stride
+ (x0 + vinfo.xoffset);

int x, y;
for (y = 0; y < height; ++y) {
for (x = 0; x < width; ++x) {
dest[x] = color15;
}
dest += stride;
}
}

void drawRect_palette(int x0, int y0, int width, int height, int color)
{
const int bytesPerPixel = 1;
const int stride = finfo.line_length / bytesPerPixel;
const unsigned char color8 = color;

unsigned char *dest = (unsigned char*)(frameBuffer)
+ (y0 + vinfo.yoffset) * stride
+ (x0 + vinfo.xoffset);

int x, y;
for (y = 0; y < height; ++y) {
for (x = 0; x < width; ++x) {
dest[x] = color8;
}
dest += stride;
}
}


void drawRect(int x0, int y0, int width, int height, int color)
{
switch (vinfo.bits_per_pixel)
{
case 32:
drawRect_rgb32(x0, y0, width, height, color);
break;
case 18:
drawRect_rgb18(x0, y0, width, height, color);
break;
case 16:
drawRect_rgb16(x0, y0, width, height, color);
break;
case 15:
drawRect_rgb15(x0, y0, width, height, color);
break;
case 8:
drawRect_palette(x0, y0, width, height, color);
break;
case 4:
drawRect_palette(x0, y0, width, height, color);
break;
default:
printf("Warning: drawRect() not implemented for color depth %i\n",
vinfo.bits_per_pixel);
break;
}
}

int main(int argc,char *argv[])
{
const char *devfile = argv[1];//argv[1]= /dev/fb0

long int screensize = 0;
/* Open the file for reading and writing */
fbFd = open(devfile, O_RDWR);
if (fbFd == -1) {
perror("Error: cannot open framebuffer device");
exit(1);
}
printf("The framebuffer device was opened successfully.\n\n");

/* Get fixed screen information */
if (ioctl(fbFd, FBIOGET_FSCREENINFO, &finfo) == -1) {
perror("Error reading fixed information");
exit(2);
}

printFixedInfo();

/* Figure out the size of the screen in bytes */
screensize = finfo.smem_len;
//sleep(10);
/* Map the device to memory */
frameBuffer = (char *)mmap(0, screensize, PROT_READ | PROT_WRITE, MAP_SHARED,fbFd, 0);
if (frameBuffer == MAP_FAILED) {
perror("Error: Failed to map framebuffer device to memory");
exit(4);
}
printf("The framebuffer device was mapped to memory successfully.\n"
"\n");


/* Get variable screen information */
if (ioctl(fbFd, FBIOGET_VSCREENINFO, &vinfo) == -1) {
perror("Error reading variable information");
exit(3);
}

printVariableInfo();

performSpeedTest(frameBuffer, screensize);

printf("vinfo.bits_per_pixel=%d\n",vinfo.bits_per_pixel);
printf("Will draw 3 rectangles on the screen,\n"
"they should be colored red, green and blue (in that order).\n");
drawRect(vinfo.xres / 8, vinfo.yres / 8,
vinfo.xres / 4, vinfo.yres / 4,
0xffff0000);
drawRect(vinfo.xres * 3 / 8, vinfo.yres * 3 / 8,
vinfo.xres / 4, vinfo.yres / 4,
0xff00ff00);
drawRect(vinfo.xres * 5 / 8, vinfo.yres * 5 / 8,
vinfo.xres / 4, vinfo.yres / 4,
0xff0000ff);
//sleep(5);
return 0;
}

=====================================运行过程如下:=========================

root@am335x-evm:~# ./fb /dev/fb0
The framebuffer device was opened successfully.

Fixed screen info:
id: DRM emulated
smem_start: 0x0
smem_len: 2621440
type: 0
type_aux: 0
visual: 2
xpanstep: 1
ypanstep: 1
ywrapstep: 0
line_length: 2560
mmio_start: 0x0
mmio_len: 0
accel: 0

The framebuffer device was mapped to memory successfully.

Variable screen info:
xres: 1280
yres: 1024
xres_virtual: 1280
yres_virtual: 1024
yoffset: 0
xoffset: 0
bits_per_pixel: 16
grayscale: 0
red: offset: 11, length: 5, msb_right: 0
green: offset: 5, length: 6, msb_right: 0
blue: offset: 0, length: 5, msb_right: 0
transp: offset: 0, length: 0, msb_right: 0
nonstd: 0
activate: 0
height: 300
width: 530
accel_flags: 0x1
pixclock: 0
left_margin: 0
right_margin: 0
upper_margin: 0
lower_margin: 0
hsync_len: 0
vsync_len: 0
sync: 0
vmode: 0

Frame Buffer Performance test...
Average: 10630 usecs
Bandwidth: 235.183 MByte/Sec
Max. FPS: 94.073 fps

vinfo.bits_per_pixel=16
Will draw 3 rectangles on the screen,
they should be colored red, green and blue (in that order).