DokuWiki

Souce Code는 다음과 같다.

#include	<stdio.h>
#include	<stdint.h>
#include	<string.h>		/* for memset */
#include	<unistd.h>		/* for open/close .. */
#include	<fcntl.h>		/* for O_RDWR */
#include	<sys/ioctl.h>	/* for ioctl */
#include	<sys/mman.h>	/* for mmap */
#include	<linux/fb.h>	/* for fb_var_screeninfo, FBIOGET_VSCREENINFO */

#include	"drm.h"	/* /home/stephanos/VI/gcc-linaro-6.3.1-2017.05-x86_64_arm-linux-gnueabihf/arm-linux-gnueabihf/libc/usr/include/drm -> check Makefile */
#include	"drm_mode.h"

#define	DEFAULT_FRAME_BUFFER_FILE	"/dev/fb0"
#define	DEV_LCD_DRM					"/dev/dri/card0"


#define	MAXIMUM_NUMBER_OF_CONNECTORS				10
#define	MAXIMUM_NUMBER_OF_CONNECTOR_RESOURCE_BUFFER	20

typedef	struct
{
	void *		pBuffer;
	uint32_t	ByteSizeOfBuffer;
	uint32_t	ScreenWidth;
	uint32_t	ScreenHeight;
} FrameBuffer_t;





typedef	struct
{
	uint64_t	pFB_ID[MAXIMUM_NUMBER_OF_CONNECTORS];
	uint64_t	pCRTC_ID[MAXIMUM_NUMBER_OF_CONNECTORS];
	uint64_t	pCONNECTOR_ID[MAXIMUM_NUMBER_OF_CONNECTORS];
	uint64_t	pENCODER_ID[MAXIMUM_NUMBER_OF_CONNECTORS];
} DRMResourceBuffer_t;

typedef	struct
{
	struct	drm_mode_modeinfo	pMode[MAXIMUM_NUMBER_OF_CONNECTOR_RESOURCE_BUFFER];
	uint64_t					pProps[MAXIMUM_NUMBER_OF_CONNECTOR_RESOURCE_BUFFER];
	uint64_t					PPropValue[MAXIMUM_NUMBER_OF_CONNECTOR_RESOURCE_BUFFER];
	uint64_t					pEncoder[MAXIMUM_NUMBER_OF_CONNECTOR_RESOURCE_BUFFER];
} DRMConnectorResourceBuffer_t;

typedef	struct
{
	struct	drm_mode_create_dumb	Create;
	struct	drm_mode_map_dumb		Map;
	struct	drm_mode_fb_cmd			Cmd;
} DRMdumbBuffer_t;





typedef	struct
{
	int							Device;

	void *						pFrameBuffer;

	struct	fb_var_screeninfo	var;
	struct	fb_fix_screeninfo	fix;
} FrameBufferContext_t;



void	drm_draw_pixel(	FrameBuffer_t *pFrameBuffer,
						uint32_t X,
						uint32_t Y,
						uint32_t Color/*(b << 16) | (g << 8) | (r << 0)*/)
{
	if ( pFrameBuffer != (FrameBuffer_t *)0 )
	{
		if ((pFrameBuffer->ScreenWidth > X)
		 &&	(pFrameBuffer->ScreenHeight > Y))
		{
			*(((uint32_t*)pFrameBuffer->pBuffer ) + Y * pFrameBuffer->ScreenWidth + X) = Color;
		}
	}
}

void	drm_draw_test_pattern(FrameBuffer_t *pFrameBuffer)
{
	uint32_t	x;
	uint32_t	y;
	uint32_t	h;
	uint32_t	w;

	h = pFrameBuffer->ScreenHeight;
	w = pFrameBuffer->ScreenWidth;
	for (y = 0; y < h; y++)
	{
		for (x = 0; x < w; x++)
		{
			if (x < 20 && y < 20)
			{
				drm_draw_pixel(pFrameBuffer, x, y, 0xffffff);
			}
			else if (x < 20 && (y > 20 && y < h - 20))
			{
				drm_draw_pixel(pFrameBuffer, x, y, 0xff);
			}
			else if (y < 20 && (x > 20 && x < w - 20))
			{
				drm_draw_pixel(pFrameBuffer, x, y, 0xff00);
			}
			else if (x > w - 20 && (y > 20 && y < h - 20))
			{
				drm_draw_pixel(pFrameBuffer, x, y, 0xff0000);
			}
			else if (y > h - 20 && (x > 20 && x < w - 20))
			{
				drm_draw_pixel(pFrameBuffer, x, y, 0xffff00);
			}
			else if (x == 20 || x == w - 20 ||
					y == 20 || y == h - 20)
			{
				drm_draw_pixel(pFrameBuffer, x, y, 0xffffff);
			}
			else if (x == y || w - x == h - y)
			{
				drm_draw_pixel(pFrameBuffer, x, y, 0xff00ff);
			}
			else if (w - x == y || x == h - y)
			{
				drm_draw_pixel(pFrameBuffer, x, y, 0x00ffff);
			}

			else if (x > 20 && y > 20 && x < w - 20 && y < h - 20)
			{
				int t = x * 3 / w;
				unsigned r = 0, g = 0, b = 0;
				unsigned c;
				if (t == 0)
				{
					b = (y % 256);
				}
				else if (t == 1)
				{
					g = (y % 256);
				}
				else if (t == 2)
				{
					r = (y % 256);
				}
				c = (b << 16) | (g << 8) | (r << 0);
				drm_draw_pixel(pFrameBuffer, x, y, c);
			}
			else
			{
				drm_draw_pixel(pFrameBuffer, x, y, 0);
			}
		}
	}
}

void	drm_fill_screen(FrameBuffer_t *pFrameBuffer,
						uint32_t Color/*(b << 16) | (g << 8) | (r << 0)*/)
{
	uint32_t	X;
	uint32_t	Y;

	if ( pFrameBuffer != (FrameBuffer_t *)0 )
	{
		for (Y = 0; Y < pFrameBuffer->ScreenHeight; Y++)
		{
			for (X = 0; X < pFrameBuffer->ScreenWidth; X++)
			{
				*(((uint32_t*)pFrameBuffer->pBuffer ) + Y * pFrameBuffer->ScreenWidth + X) = Color;
			}
		}
	}
}


void	fb_draw_pixel(	FrameBufferContext_t *pFrameBufferContext,
					uint32_t X,
					uint32_t Y,
					uint32_t Color)
{
	void *	pFrameBuffer;

	pFrameBuffer = pFrameBufferContext->pFrameBuffer;
	if (pFrameBufferContext->var.bits_per_pixel == 8)
	{
		unsigned char *		p;

		pFrameBuffer += pFrameBufferContext->fix.line_length * Y;
		p = pFrameBuffer;
		p += X;

		*p = (unsigned char)Color;
	}
	else if (pFrameBufferContext->var.bits_per_pixel == 16)
	{
		unsigned short *	p;

		pFrameBuffer += pFrameBufferContext->fix.line_length * Y;
		p = pFrameBuffer;
		p += X;

		*p = (unsigned short)(((((Color >> 16) & 0xff) * 32 / 256) << 11) | ((((Color >> 8) & 0xff) * 64 / 256) << 5) | ((((Color >> 0) & 0xff) * 32 / 256) << 0));
	}
	else if (pFrameBufferContext->var.bits_per_pixel == 24)
	{
		unsigned char *		p;

		p = (unsigned char *)pFrameBuffer + pFrameBufferContext->fix.line_length * Y + 3 * X;

		*p++ = (unsigned char)Color;
		*p++ = (unsigned char)(Color >> 8);
		*p = (unsigned char)(Color >> 16);
	}
	else
	{
		uint32_t *		p;

		pFrameBuffer += pFrameBufferContext->fix.line_length * Y;
		p = pFrameBuffer;
		p += X;

		*p = Color;
	}
}


void	fill_screen(FrameBufferContext_t *pFrameBufferContext)
{
	uint32_t	x;
	uint32_t	y;
	uint32_t	h;
	uint32_t	w;

	h = pFrameBufferContext->var.yres;
	w = pFrameBufferContext->var.xres;
	for (y = 0; y < h; y++)
	{
		for (x = 0; x < w; x++)
		{
			if (x < 20 && y < 20)
			{
				fb_draw_pixel(pFrameBufferContext, x, y, 0xffffff);
			}
			else if (x < 20 && (y > 20 && y < h - 20))
			{
				fb_draw_pixel(pFrameBufferContext, x, y, 0xff);
			}
			else if (y < 20 && (x > 20 && x < w - 20))
			{
				fb_draw_pixel(pFrameBufferContext, x, y, 0xff00);
			}
			else if (x > w - 20 && (y > 20 && y < h - 20))
			{
				fb_draw_pixel(pFrameBufferContext, x, y, 0xff0000);
			}
			else if (y > h - 20 && (x > 20 && x < w - 20))
			{
				fb_draw_pixel(pFrameBufferContext, x, y, 0xffff00);
			}
			else if (x == 20 || x == w - 20 ||
					y == 20 || y == h - 20)
			{
				fb_draw_pixel(pFrameBufferContext, x, y, 0xffffff);
			}
			else if (x == y || w - x == h - y)
			{
				fb_draw_pixel(pFrameBufferContext, x, y, 0xff00ff);
			}
			else if (w - x == y || x == h - y)
			{
				fb_draw_pixel(pFrameBufferContext, x, y, 0x00ffff);
			}

			else if (x > 20 && y > 20 && x < w - 20 && y < h - 20)
			{
				int t = x * 3 / w;
				unsigned r = 0, g = 0, b = 0;
				unsigned c;
				if (pFrameBufferContext->var.bits_per_pixel == 16)
				{
					if (t == 0)
					{
						b = (y % 32) * 256 / 32;
					}
					else if (t == 1)
					{
						g = (y % 64) * 256 / 64;
					}
					else if (t == 2)
					{
						r = (y % 32) * 256 / 32;
					}
				}
				else
				{
					if (t == 0)
					{
						b = (y % 256);
					}
					else if (t == 1)
					{
						g = (y % 256);
					}
					else if (t == 2)
					{
						r = (y % 256);
					}
				}
				c = (b << 16) | (g << 8) | (r << 0);
				fb_draw_pixel(pFrameBufferContext, x, y, c);
			}
			else
			{
				fb_draw_pixel(pFrameBufferContext, x, y, 0);
			}
		}
	}
}


void	clear_area(	FrameBufferContext_t *pFrameBufferContext,
					uint32_t X,
					uint32_t Y,
					uint32_t W,
					uint32_t H)
{
	uint32_t	AddressOffsetForH;
	uint32_t	CountForH;
	unsigned char *	pFrameBuffer;

	pFrameBuffer = (unsigned char *)pFrameBufferContext->pFrameBuffer;

	for (CountForH = 0; CountForH < H; CountForH++)
	{
		AddressOffsetForH = (X + pFrameBufferContext->var.xoffset) * (pFrameBufferContext->var.bits_per_pixel / 8)
			+ (Y + CountForH + pFrameBufferContext->var.yoffset) * pFrameBufferContext->fix.line_length;

		memset(pFrameBuffer + AddressOffsetForH, 0, W * pFrameBufferContext->var.bits_per_pixel / 8);
	}
}


int	device_open_mode(FrameBufferContext_t *pFrameBufferContext, int BitPerPixel)
{
	pFrameBufferContext->Device = open(DEFAULT_FRAME_BUFFER_FILE, O_RDWR);
	if(pFrameBufferContext->Device < 0)
	{
		printf("Faile to open : %s \n", DEFAULT_FRAME_BUFFER_FILE);
		return	-1;
	}

	if(ioctl(pFrameBufferContext->Device, FBIOGET_VSCREENINFO, &pFrameBufferContext->var) < 0)
	{
		printf("fbdev ioctl(VSCREENINFO)\n");
		close(pFrameBufferContext->Device);
		return	-1;
	}

	if(ioctl(pFrameBufferContext->Device, FBIOGET_FSCREENINFO, &pFrameBufferContext->fix) < 0)
	{
		printf("fbdev ioctl(FSCREENINFO)\n");
		close(pFrameBufferContext->Device);
		return	-1;
	}

	if(pFrameBufferContext->var.bits_per_pixel != BitPerPixel)
	{
		pFrameBufferContext->var.bits_per_pixel = BitPerPixel;
		if(ioctl(pFrameBufferContext->Device, FBIOPUT_VSCREENINFO, &pFrameBufferContext->var) < 0)
		{
			printf("fbdev ioctl(PUT)\n");
			close(pFrameBufferContext->Device);
			return	-1;
		}
	}

	return	0;
}


int	device_open(FrameBufferContext_t *pFrameBufferContext)
{
	if(device_open_mode(pFrameBufferContext, 8) != 0)
	{
		printf("Faile to open with 8bit: %s \n", DEFAULT_FRAME_BUFFER_FILE);
		return	-1;
	}
	close(pFrameBufferContext->Device);

	if(device_open_mode(pFrameBufferContext, 24) != 0)
	{
		printf("Faile to open with 24bit: %s \n", DEFAULT_FRAME_BUFFER_FILE);
		return	-1;
	}

	printf("x-resolution : %d\n", pFrameBufferContext->var.xres);
	printf("y-resolution : %d\n", pFrameBufferContext->var.yres);
	printf("x-resolution(virtual) : %d\n", pFrameBufferContext->var.xres_virtual);
	printf("y-resolution(virtual) : %d\n", pFrameBufferContext->var.yres_virtual);
	printf("bpp : %d\n", pFrameBufferContext->var.bits_per_pixel);
	printf("length of frame buffer memory : %d\n", pFrameBufferContext->fix.smem_len);

	return	0;
}

static	int	test_simple_fb_style(void)
{
	FrameBufferContext_t	FrameBufferContext;
	int						Error;

	printf("Opening frame buffer device `%s'\n", DEFAULT_FRAME_BUFFER_FILE);

	if(device_open(&FrameBufferContext) != 0)
	{
		printf("Fail to Device Open\n");
		return	0;
	}

	FrameBufferContext.pFrameBuffer = mmap(0,
			FrameBufferContext.var.yres_virtual * FrameBufferContext.fix.line_length,
			PROT_WRITE | PROT_READ,
			MAP_SHARED,
			FrameBufferContext.Device,
			0);

	if(FrameBufferContext.pFrameBuffer == MAP_FAILED)
	{
		printf("Frame buffer MAP fail !\n");
		close(FrameBufferContext.Device);
		return	0;
	}

/* Display pattern to screen */
	fill_screen(&FrameBufferContext);

/* End of... */
	munmap(	FrameBufferContext.pFrameBuffer,
			FrameBufferContext.var.yres_virtual * FrameBufferContext.fix.line_length);

	close(FrameBufferContext.Device);

	return	0;
}





static	int	drm_open(void)
{
	int			Device;
	int			Flags;
	uint64_t	HasDumbBuffer;

	Device = -1;
	if ( access(DEV_LCD_DRM, F_OK) )
	{
		printf("no device - %s\n", DEV_LCD_DRM);
		return	0;
	}

	if ( (Device = open(DEV_LCD_DRM, O_RDWR)) <= 0 )
	{
		printf("Faile to open : %s \n", DEV_LCD_DRM);
		return	0;
	}

	//	set FD_CLOEXEC flag
	Flags = fcntl(Device, F_GETFD);
	if (Flags < 0)
	{
		printf("Faile to read Flags \n");
		close(Device);
		return	0;
	}
	if ( fcntl(Device, F_SETFD, Flags | FD_CLOEXEC) < 0 )
	{
		printf("Faile to set Falsgs FD_CLOEXEC \n");
		close(Device);
		return	0;
	}

	return	Device;
}


static	int	drm_get_frame_buffer(FrameBuffer_t *pFrameBuffer,
								int Device,
								uint64_t * pConnectorID)
{
	struct	drm_mode_get_connector	ConnectorResource = {0};
	DRMConnectorResourceBuffer_t	DRMConnectorResourceBuffer = {0};
	DRMdumbBuffer_t					DRMdumbBuffer = {0};
	struct	drm_mode_get_encoder	Encoder = {0};
	struct	drm_mode_crtc			CRTC = {0};

	if ((pFrameBuffer != (FrameBuffer_t *)0)
	 &&	(pConnectorID != (uint64_t * )0) )
	{
		//	get connector resource counts
		ConnectorResource.connector_id = *pConnectorID;
		ioctl(Device, DRM_IOCTL_MODE_GETCONNECTOR, &ConnectorResource);

		//	get connector resources
		ConnectorResource.modes_ptr = (uint64_t)DRMConnectorResourceBuffer.pMode;
		ConnectorResource.props_ptr = (uint64_t)DRMConnectorResourceBuffer.pProps;
		ConnectorResource.prop_values_ptr = (uint64_t)DRMConnectorResourceBuffer.PPropValue;
		ConnectorResource.encoders_ptr = (uint64_t)DRMConnectorResourceBuffer.pEncoder;
		ioctl(Device, DRM_IOCTL_MODE_GETCONNECTOR, &ConnectorResource);

		//	Check if the connector is OK to use (connected to something)
		if ((ConnectorResource.count_encoders > 0)
		 &&	(ConnectorResource.count_modes > 0)
		 && (ConnectorResource.encoder_id != 0)
		 && (ConnectorResource.connection != 0)	)
		{
			//	Creating a dumb buffer
			//	If we create the buffer later, we can get the size of the screen first.
			//	This must be a valid mode, so it's probably best to do this after we find a valid crtc with modes.
			DRMdumbBuffer.Create.width = DRMConnectorResourceBuffer.pMode[0].hdisplay;
			DRMdumbBuffer.Create.height = DRMConnectorResourceBuffer.pMode[0].vdisplay;
			DRMdumbBuffer.Create.bpp = 32;
			DRMdumbBuffer.Create.flags = 0;	/* must be zero */
			DRMdumbBuffer.Create.pitch = 0;
			DRMdumbBuffer.Create.size = 0;
			DRMdumbBuffer.Create.handle = 0;
			if(ioctl(Device, DRM_IOCTL_MODE_CREATE_DUMB, &DRMdumbBuffer.Create) < 0)
			{
				printf("Fail to create dumb buffer\n");
			};

			DRMdumbBuffer.Cmd.width=DRMdumbBuffer.Create.width;
			DRMdumbBuffer.Cmd.height=DRMdumbBuffer.Create.height;
			DRMdumbBuffer.Cmd.bpp=DRMdumbBuffer.Create.bpp;
			DRMdumbBuffer.Cmd.pitch=DRMdumbBuffer.Create.pitch;
			DRMdumbBuffer.Cmd.depth=24;
			DRMdumbBuffer.Cmd.handle=DRMdumbBuffer.Create.handle;
			ioctl(Device,DRM_IOCTL_MODE_ADDFB,&DRMdumbBuffer.Cmd);

			DRMdumbBuffer.Map.handle=DRMdumbBuffer.Create.handle;
			ioctl(Device,DRM_IOCTL_MODE_MAP_DUMB,&DRMdumbBuffer.Map);

			pFrameBuffer->pBuffer = mmap(0, DRMdumbBuffer.Create.size, PROT_READ | PROT_WRITE, MAP_SHARED, Device, DRMdumbBuffer.Map.offset);
			pFrameBuffer->ByteSizeOfBuffer = DRMdumbBuffer.Create.size;
			pFrameBuffer->ScreenWidth = DRMdumbBuffer.Create.width;
			pFrameBuffer->ScreenHeight = DRMdumbBuffer.Create.height;

//		drmIoctl(fd, DRM_IOCTL_MODE_DESTROY_DUMB, &dreq);

			//	Kernel Mode Setting (KMS)
			printf("Connection %d : mode: %d, prop: %d, enc: %d\n",
					ConnectorResource.connection,
					ConnectorResource.count_modes,
					ConnectorResource.count_props,
					ConnectorResource.count_encoders);
			printf("modes: %dx%d Frame Buffer Address: 0x%X Frame Buffer Byte Size: 0x%X(%d) \n",
					DRMConnectorResourceBuffer.pMode[0].hdisplay,
					DRMConnectorResourceBuffer.pMode[0].vdisplay,
					pFrameBuffer->pBuffer,
					pFrameBuffer->ByteSizeOfBuffer, pFrameBuffer->ByteSizeOfBuffer);

			//	get encoder
			Encoder.encoder_id = ConnectorResource.encoder_id;
			ioctl(Device, DRM_IOCTL_MODE_GETENCODER, &Encoder);

			CRTC.crtc_id = Encoder.crtc_id;
			ioctl(Device, DRM_IOCTL_MODE_GETCRTC, &CRTC);

			CRTC.fb_id = DRMdumbBuffer.Cmd.fb_id;
			CRTC.set_connectors_ptr = (uint64_t)pConnectorID;
			CRTC.count_connectors = 1;
			CRTC.mode = DRMConnectorResourceBuffer.pMode[0];
			CRTC.mode_valid = 1;
			ioctl(Device, DRM_IOCTL_MODE_SETCRTC, &CRTC);

			return	0;
		}
		else
		{
			printf("Not connected\n");
		}
	}

	return	-1;
}


static	int	drm_free_frame_buffer(FrameBuffer_t *pFrameBuffer)
{
	if (pFrameBuffer != (FrameBuffer_t *)0)
	{
		if (pFrameBuffer->ByteSizeOfBuffer != 0)
		{
			munmap(	pFrameBuffer->pBuffer, pFrameBuffer->ByteSizeOfBuffer );
			printf("Free Frame Buffer\n");

			return	0;
		}
	}

	return	-1;
}


static	int	test_drm_style(void)
{
	int							Device;
	uint32_t					ConnectorIndex;
	uint32_t					Color;
	struct	drm_mode_card_res	Resource = {0};
	DRMResourceBuffer_t			DRMResourceBuffer = {0};

	Device = drm_open();
	if ( Device != 0 )
	{
		FrameBuffer_t	pFrameBuffer[MAXIMUM_NUMBER_OF_CONNECTORS];

		printf("DRM opened !\n");

		//	Kernel Mode Setting (KMS)
		//	Become the "master" of the DRI device
		ioctl(Device, DRM_IOCTL_SET_MASTER, 0);
		printf("DRM DRM_IOCTL_SET_MASTER\n");

		//	Get resource counts
		ioctl(Device, DRM_IOCTL_MODE_GETRESOURCES, &Resource);
		Resource.fb_id_ptr = (uint64_t)DRMResourceBuffer.pFB_ID;
		Resource.crtc_id_ptr = (uint64_t)DRMResourceBuffer.pCRTC_ID;
		Resource.connector_id_ptr = (uint64_t)DRMResourceBuffer.pCONNECTOR_ID;
		Resource.encoder_id_ptr = (uint64_t)DRMResourceBuffer.pENCODER_ID;

		//	Get resource IDs
		ioctl(Device, DRM_IOCTL_MODE_GETRESOURCES, &Resource);
		printf("Get Resource ID fb: %d, crtc: %d, conn: %d, enc: %d\n",
				Resource.count_fbs,
				Resource.count_crtcs,
				Resource.count_connectors,
				Resource.count_encoders);

		//	Loop though all available connectors
		for (ConnectorIndex = 0; ConnectorIndex < Resource.count_connectors; ConnectorIndex++)
		{
			drm_get_frame_buffer(&pFrameBuffer[ConnectorIndex], Device, &DRMResourceBuffer.pCONNECTOR_ID[ConnectorIndex]);
		}

		//	Stop being the "master" of the DRI device
		ioctl(Device, DRM_IOCTL_DROP_MASTER, 0);
		printf("DRM DRM_IOCTL_DROP_MASTER\n");


		int	j;
		for (j = 0; j < 100; j++)
		{
			for (ConnectorIndex = 0; ConnectorIndex < Resource.count_connectors; ConnectorIndex++)
			{
				drm_fill_screen(&pFrameBuffer[ConnectorIndex], 0x00000000);
				usleep(100000);
				Color = (rand() % 0x00ffffff) & 0x00ff00ff;
				drm_fill_screen(&pFrameBuffer[ConnectorIndex], Color);
				usleep(100000);
				for (uint32_t k = 0; k <255; k++)
				{
					drm_fill_screen(&pFrameBuffer[ConnectorIndex], (Color | (k << 24)));
				}
				drm_draw_test_pattern(&pFrameBuffer[ConnectorIndex]);
				usleep(100000);
			}
		}

//DRM_IOCTL_MODE_DESTROY_DUMB

		for (ConnectorIndex = 0; ConnectorIndex < Resource.count_connectors; ConnectorIndex++)
		{
			drm_free_frame_buffer(&pFrameBuffer[ConnectorIndex]);
		}

		close(Device);
		printf("DRM closed !\n");
	}

}


int	main()
{
	printf("Test Symple FB Style\n");
	test_simple_fb_style();

	printf("Test DRM Style\n");
	test_drm_style();

	return	0;
}

test_app_002.zip

아래와 같이 컴파일 한다.

stephanos@stephanos-VirtualBox:~/VI/App$ /home/stephanos/VI/gcc-linaro-6.2.1-2016.11-x86_64_arm-linux-gnueabihf/bin/arm-linux-gnueabihf-gcc -I$/home/stephanos/VI/gcc-linaro-6.2.1-2016.11-x86_64_arm-linux-gnueabihf/arm-linux-gnueabihf/libc/usr/include/drm -o test test.c

NFS에 위에서 만들어진 test를 복사한다. Target Board를 NFS로 부팅한다.

로그인 후 아래와 같이 실행한다.