WebSVN – Kolibri OS – Blame – /drivers/video/drm/i915/kms_display.c

Rev	Author	Line No.	Line
2340	Serge	1
		2
		3
2338	Serge	4	#include "drm.h"
		5	#include "i915_drm.h"
		6	#include "i915_drv.h"
		7	#include "intel_drv.h"
		8
		9
		10	#include
		11	#include
		12	#include
		13	#include
		14
		15
		16
		17
2340	Serge	18
2338	Serge	19
		20	{
		21	kobj_t header;
		22
		23
		24	uint32_t hot_x;
		25	uint32_t hot_y;
		26
		27
		28	struct drm_i915_gem_object *cobj;
		29	}cursor_t;
		30
		31
		32	#define CURSOR_HEIGHT 64
		33
		34
		35
		36	{
		37	int x;
		38	int y;
		39	int width;
		40	int height;
		41	int bpp;
		42	int vrefresh;
		43	int pitch;
		44	int lfb;
		45
		46
		47	struct drm_device *ddev;
		48	struct drm_connector *connector;
		49	struct drm_crtc *crtc;
		50
		51
		52
		53
		54	int (init_cursor)(cursor_t);
		55	cursor_t* (__stdcall select_cursor)(cursor_t);
		56	void (*show_cursor)(int show);
		57	void (__stdcall move_cursor)(cursor_t cursor, int x, int y);
		58	void (__stdcall *restore_cursor)(int x, int y);
		59	void (*disable_mouse)(void);
		60	u32 mask_seqno;
2361	Serge	61	u32 check_mouse;
3031	serge	62	u32 check_m_pixel;
		63
		64
2338	Serge	65
		66
		67
		68
		69
2340	Serge	70	u32_t cmd_offset;
		71
		72
2351	Serge	73	int sna_init();
		74
		75
2338	Serge	76	static cursor_t* __stdcall select_cursor_kms(cursor_t *cursor);
		77	static void __stdcall move_cursor_kms(cursor_t *cursor, int x, int y);
		78
		79
		80	{};
		81
		82
		83	{};
		84
		85
3031	serge	86	{
		87	static char name[4];
		88
		89
		90	name[1] = ((x[0] & 0x03) << 3) + ((x[1] & 0xE0) >> 5) + '@';
		91	name[2] = (x[1] & 0x1F) + '@';
		92	name[3] = 0;
		93
		94
		95	}
		96
		97
		98	videomode_t *reqmode, bool strict)
		99	{
		100	drm_i915_private_t *dev_priv = dev->dev_private;
		101	struct drm_fb_helper *fb_helper = &dev_priv->fbdev->helper;
		102
		103
		104	struct drm_display_mode mode = NULL, tmpmode;
		105	struct drm_framebuffer *fb = NULL;
		106	struct drm_crtc *crtc;
		107	struct drm_encoder *encoder;
		108	struct drm_i915_gem_object *fb_obj;
4280	Serge	109	struct drm_mode_set set;
3031	serge	110	const char *con_name;
4371	Serge	111	const char *enc_name;
		112	unsigned hdisplay, vdisplay;
3031	serge	113	int stride;
4557	Serge	114	int ret;
3031	serge	115
		116
		117
		118
		119	{
		120	if( (drm_mode_width(tmpmode) == reqmode->width) &&
		121	(drm_mode_height(tmpmode) == reqmode->height) &&
		122	(drm_mode_vrefresh(tmpmode) == reqmode->freq) )
		123	{
		124	mode = tmpmode;
		125	goto do_set;
		126	}
		127	};
		128
		129
		130	{
		131	list_for_each_entry(tmpmode, &connector->modes, head)
		132	{
		133	if( (drm_mode_width(tmpmode) == reqmode->width) &&
		134	(drm_mode_height(tmpmode) == reqmode->height) )
		135	{
		136	mode = tmpmode;
		137	goto do_set;
		138	}
		139	};
		140	};
		141
		142
3037	serge	143
3031	serge	144
		145
		146
		147
		148
		149	crtc = encoder->crtc;
		150
		151
		152	enc_name = drm_get_encoder_name(encoder);
		153
		154
		155	reqmode->width, reqmode->height, crtc->base.id,
		156	con_name, enc_name);
		157
		158
		159
		160
		161	vdisplay = mode->vdisplay;
		162
		163
		164	swap(hdisplay, vdisplay);
		165
		166
4280	Serge	167	fb = fb_helper->fb;
3031	serge	168
		169
		170	fb->height = reqmode->height;
		171
		172
4557	Serge	173	{
		174	fb_obj->tiling_mode = I915_TILING_X;
		175
4280	Serge	176
4557	Serge	177	for (stride = 512; stride < reqmode->width * 4; stride <<= 1);
		178	else
		179	stride = ALIGN(reqmode->width * 4, 512);
		180	}
		181	else
		182	{
		183	fb_obj->tiling_mode = I915_TILING_NONE;
		184	stride = ALIGN(reqmode->width * 4, 64);
		185	}
		186
4280	Serge	187
4557	Serge	188	fb->pitches[1] =
		189	fb->pitches[2] =
		190	fb->pitches[3] = stride;
		191
		192
		193
		194
3031	serge	195	fb->depth = 24;
		196
		197
		198	crtc->enabled = true;
		199	os_display->crtc = crtc;
		200
		201
4280	Serge	202
		203
3031	serge	204	set.x = 0;
		205	set.y = 0;
		206	set.mode = mode;
		207	set.connectors = &connector;
		208	set.num_connectors = 1;
		209	set.fb = fb;
		210	ret = crtc->funcs->set_config(&set);
		211	mutex_unlock(&dev->mode_config.mutex);
		212
		213
		214	{
		215	os_display->width = fb->width;
		216	os_display->height = fb->height;
		217	os_display->vrefresh = drm_mode_vrefresh(mode);
		218
		219
		220
		221
3037	serge	222	fb->width, fb->height, fb->pitches[0]);
3031	serge	223	}
		224	else
		225	DRM_ERROR("failed to set mode %d_%d on crtc %p\n",
		226	fb->width, fb->height, crtc);
		227
		228
		229	}
		230
		231
2338	Serge	232	{
		233	struct drm_display_mode *mode;
		234	int count = 0;
		235
		236
		237	{
		238	count++;
		239	};
		240	return count;
		241	};
		242
		243
3031	serge	244	{
		245	struct drm_connector *connector;
		246	struct drm_connector_helper_funcs *connector_funcs;
		247
		248
		249
		250
		251	{
		252	struct drm_encoder *encoder;
		253	struct drm_crtc *crtc;
		254
		255
		256	continue;
		257
		258
		259	encoder = connector_funcs->best_encoder(connector);
		260	if( encoder == NULL)
		261	continue;
		262
		263
		264
		265
		266
		267
3037	serge	268	connector, connector->base.id,
3031	serge	269	connector->status, connector->encoder,
		270	crtc);
		271
		272
		273	// continue;
		274
		275
		276
		277
		278	};
		279
		280
		281	};
		282
		283
4371	Serge	284	{
2338	Serge	285	struct drm_connector *tmp = NULL;
4371	Serge	286	struct drm_connector_helper_funcs *connector_funcs;
2338	Serge	287	struct drm_encoder *encoder;
		288
		289
4371	Serge	290	{
2338	Serge	291	if( tmp->status != connector_status_connected)
4371	Serge	292	continue;
2338	Serge	293
		294
4371	Serge	295	encoder = connector_funcs->best_encoder(tmp);
		296	if( encoder == NULL)
2338	Serge	297	{
		298	DRM_DEBUG_KMS("CONNECTOR %x ID: %d no active encoders\n",
3037	serge	299	tmp, tmp->base.id);
4371	Serge	300	continue;
2338	Serge	301	};
4371	Serge	302
2338	Serge	303
4371	Serge	304
		305
4280	Serge	306	tmp, tmp->base.id, tmp->status, tmp->encoder,
4371	Serge	307	tmp->encoder->crtc, tmp->encoder->crtc->base.id );
		308
2338	Serge	309
4371	Serge	310	};
2338	Serge	311
		312
4371	Serge	313	}
		314
4280	Serge	315
4371	Serge	316	{
4398	Serge	317	struct drm_crtc *tmp_crtc;
2338	Serge	318	int crtc_mask = 1;
		319
		320
		321	{
		322	if (encoder->possible_crtcs & crtc_mask)
		323	{
		324	encoder->crtc = tmp_crtc;
4371	Serge	325	dbgprintf("CRTC %p\n", tmp_crtc);
		326	return tmp_crtc;
		327	};
2338	Serge	328	crtc_mask <<= 1;
		329	};
		330	return NULL;
4371	Serge	331	};
4398	Serge	332
2338	Serge	333
4371	Serge	334	{
		335	struct drm_display_mode *mode;
		336
		337
		338	{
		339	DRM_DEBUG_KMS("check mode w:%d h:%d %dHz\n",
4389	Serge	340	drm_mode_width(mode), drm_mode_height(mode),
4371	Serge	341	drm_mode_vrefresh(mode));
		342
		343
		344	os_display->height == drm_mode_height(mode) &&
		345	drm_mode_vrefresh(mode) == 60)
		346	{
		347	usermode->width = os_display->width;
		348	usermode->height = os_display->height;
		349	usermode->freq = 60;
		350	return 1;
		351	}
		352	}
		353	return 0;
		354	}
		355
		356
		357	{
		358	struct drm_connector *connector;
		359	struct drm_connector_helper_funcs *connector_funcs;
		360	struct drm_encoder *encoder;
		361	struct drm_crtc *crtc;
		362	struct drm_framebuffer *fb;
		363
		364
		365	u32_t ifl;
		366	int err;
		367
		368
		369
		370
		371	if(connector == NULL)
		372	{
		373	DRM_DEBUG_KMS("No active connectors!\n");
		374	mutex_unlock(&dev->mode_config.mutex);
		375	return -1;
		376	};
		377
		378
		379	crtc = encoder->crtc;
		380
		381
		382	crtc = get_possible_crtc(dev, encoder);
		383
		384
2338	Serge	385	{
		386	DRM_DEBUG_KMS("No CRTC for encoder %d\n", encoder->base.id);
4280	Serge	387	mutex_unlock(&dev->mode_config.mutex);
		388	return -1;
2338	Serge	389	};
		390
		391
4280	Serge	392
2338	Serge	393
		394	os_display->ddev = dev;
		395	os_display->connector = connector;
		396	os_display->crtc = crtc;
		397
		398
		399
		400
		401
		402	{
		403	struct intel_crtc *intel_crtc = to_intel_crtc(os_display->crtc);
		404
		405
		406	{
		407	init_cursor(cursor);
		408	};
		409
		410
		411	os_display->init_cursor = init_cursor;
		412	os_display->select_cursor = select_cursor_kms;
		413	os_display->show_cursor = NULL;
		414	os_display->move_cursor = move_cursor_kms;
		415	os_display->restore_cursor = restore_cursor;
		416	os_display->disable_mouse = disable_mouse;
		417
		418
		419	intel_crtc->cursor_y = os_display->height/2;
		420
		421
		422	};
		423	safe_sti(ifl);
		424
		425
4280	Serge	426	(usermode->height == 0))
		427	{
		428	if( !get_boot_mode(connector, usermode))
4371	Serge	429	{
		430	struct drm_display_mode *mode;
4280	Serge	431
		432
		433	usermode->width = drm_mode_width(mode);
		434	usermode->height = drm_mode_height(mode);
		435	usermode->freq = drm_mode_vrefresh(mode);
		436	};
		437	};
		438
		439
		440
		441
		442
		443
3243	Serge	444	err = init_bitmaps();
2342	Serge	445	#endif
3243	Serge	446
2340	Serge	447
4280	Serge	448
		449
2338	Serge	450	};
		451
		452
		453
		454	{
		455	int err = -1;
		456
		457
3031	serge	458
2338	Serge	459
		460	{
		461	*count = os_display->supported_modes;
		462	err = 0;
		463	}
		464	else if( mode != NULL )
		465	{
		466	struct drm_display_mode *drmmode;
		467	int i = 0;
		468
		469
		470	*count = os_display->supported_modes;
		471
		472
		473	{
		474	if( i < *count)
		475	{
		476	mode->width = drm_mode_width(drmmode);
		477	mode->height = drm_mode_height(drmmode);
		478	mode->bpp = 32;
		479	mode->freq = drm_mode_vrefresh(drmmode);
		480	i++;
		481	mode++;
		482	}
		483	else break;
		484	};
		485	*count = i;
		486	err = 0;
		487	};
		488	return err;
		489	};
		490
		491
		492	{
		493	int err = -1;
		494
		495
3031	serge	496	// mode->width, mode->height, mode->freq);
		497
2338	Serge	498
		499	(mode->height != 0) &&
		500	(mode->freq != 0 ) &&
		501	( (mode->width != os_display->width) \|\|
		502	(mode->height != os_display->height) \|\|
		503	(mode->freq != os_display->vrefresh) ) )
		504	{
		505	if( set_mode(os_display->ddev, os_display->connector, mode, true) )
		506	err = 0;
		507	};
		508
		509
		510	};
		511
		512
4126	Serge	513	{
		514	const struct drm_connector_funcs *f = os_display->connector->funcs;
4371	Serge	515
4126	Serge	516
		517	};
		518
		519
2338	Serge	520	{
		521	list_del(&cursor->list);
3037	serge	522
2342	Serge	523
3037	serge	524
		525
		526	drm_gem_object_unreference(&cursor->cobj->base);
		527	mutex_unlock(&main_device->struct_mutex);
		528
		529
2338	Serge	530	};
		531
		532
		533	{
		534	struct drm_i915_private *dev_priv = os_display->ddev->dev_private;
		535	struct drm_i915_gem_object *obj;
		536	uint32_t *bits;
		537	uint32_t *src;
		538	void *mapped;
3037	serge	539
2338	Serge	540
		541	int ret;
		542
		543
		544	{
		545	bits = (uint32_t)KernelAlloc(CURSOR_WIDTHCURSOR_HEIGHT*4);
		546	if (unlikely(bits == NULL))
		547	return ENOMEM;
		548	cursor->cobj = (struct drm_i915_gem_object *)GetPgAddr(bits);
		549	}
		550	else
		551	{
		552	obj = i915_gem_alloc_object(os_display->ddev, CURSOR_WIDTHCURSOR_HEIGHT4);
		553	if (unlikely(obj == NULL))
		554	return -ENOMEM;
		555
		556
4104	Serge	557	if (ret) {
2338	Serge	558	drm_gem_object_unreference(&obj->base);
2344	Serge	559	return ret;
2338	Serge	560	}
		561
		562
4104	Serge	563	if (ret)
		564	{
		565	i915_gem_object_unpin(obj);
		566	drm_gem_object_unreference(&obj->base);
		567	return ret;
		568	}
		569	/* You don't need to worry about fragmentation issues.
2338	Serge	570	* GTT space is continuous. I guarantee it. */
		571
		572
4104	Serge	573	CURSOR_WIDTHCURSOR_HEIGHT4, PG_SW);
2338	Serge	574
		575
		576	{
		577	i915_gem_object_unpin(obj);
2344	Serge	578	drm_gem_object_unreference(&obj->base);
		579	return -ENOMEM;
2338	Serge	580	};
		581	cursor->cobj = obj;
		582	};
		583
		584
		585
		586
		587	{
		588	for(j = 0; j < 32; j++)
		589	bits++ = src++;
		590	for(j = 32; j < CURSOR_WIDTH; j++)
		591	*bits++ = 0;
		592	}
		593	for(i = 0; i < CURSOR_WIDTH*(CURSOR_HEIGHT-32); i++)
		594	*bits++ = 0;
		595
		596
3037	serge	597
		598
2338	Serge	599
		600
2340	Serge	601
2338	Serge	602
		603
		604
		605
		606
		607	}
		608
		609
		610
		611	{
		612	struct drm_crtc *crtc = os_display->crtc;
4557	Serge	613	x-= cursor->hot_x;
		614	y-= cursor->hot_y;
		615
2338	Serge	616
4557	Serge	617	crtc->funcs->cursor_move(crtc, x, y);
		618
2338	Serge	619
		620
		621
		622
		623	{
		624	struct drm_i915_private *dev_priv = os_display->ddev->dev_private;
		625	struct intel_crtc *intel_crtc = to_intel_crtc(os_display->crtc);
		626	cursor_t *old;
		627
		628
		629	os_display->cursor = cursor;
		630
		631
4557	Serge	632
		633
2338	Serge	634	intel_crtc->cursor_addr = i915_gem_obj_ggtt_offset(cursor->cobj);
4104	Serge	635	else
2338	Serge	636	intel_crtc->cursor_addr = (addr_t)cursor->cobj;
2352	Serge	637
2338	Serge	638
		639	intel_crtc->cursor_height = 32;
		640
		641
		642	return old;
		643	};
		644
		645
4371	Serge	646	{
3263	Serge	647	struct drm_i915_private *dev_priv = os_display->ddev->dev_private;
4389	Serge	648	struct intel_crtc *crtc = to_intel_crtc(os_display->crtc);
		649
		650
4371	Serge	651
2340	Serge	652
4371	Serge	653	fb->width = os_display->width;
3263	Serge	654	fb->height = os_display->height;
		655	fb->pitch = obj->stride;
4371	Serge	656	fb->tiling = obj->tiling_mode;
		657	fb->crtc = crtc->base.base.id;
4389	Serge	658	fb->pipe = crtc->pipe;
		659
2340	Serge	660
3263	Serge	661	}
4371	Serge	662
3263	Serge	663
4371	Serge	664
3277	Serge	665	{
		666	int left;
		667	int top;
		668	int right;
		669	int bottom;
		670	}rect_t;
		671
3263	Serge	672
3277	Serge	673
		674
		675
		676	{
		677	u32_t addr;
		678
		679
		680	addr+= sizeof(display_t); /* shoot me */
		681	return (u32_t)addr;
		682	}
		683
		684
		685
		686
		687	struct drm_file *file)
		688	{
		689	struct drm_i915_mask *mask = data;
		690	struct drm_gem_object *obj;
		691	static unsigned int mask_seqno[256];
		692	rect_t winrc;
		693	u32 slot;
		694	int ret=0;
4371	Serge	695
3277	Serge	696
		697	if (obj == NULL)
		698	return -ENOENT;
		699
		700
		701	drm_gem_object_unreference_unlocked(obj);
		702	return -EINVAL;
		703	}
		704
		705
		706	{
		707	// static warn_count;
3298	Serge	708
3277	Serge	709
3290	Serge	710	mask->height = winrc.bottom - winrc.top + 1;
		711	mask->bo_pitch = (mask->width+15) & ~15;
		712
		713
3298	Serge	714	if(warn_count < 1)
3277	Serge	715	{
		716	printf("left %d top %d right %d bottom %d\n",
		717	winrc.left, winrc.top, winrc.right, winrc.bottom);
		718	printf("mask pitch %d data %p\n", mask->bo_pitch, mask->bo_size);
		719	warn_count++;
		720	};
		721	#endif
3298	Serge	722
		723
4104	Serge	724
3277	Serge	725
3290	Serge	726
3277	Serge	727
		728
		729	{
		730	u8* src_offset;
		731	u8* dst_offset;
		732	u32 ifl;
		733
		734
		735	if (ret)
		736	goto err1;
4371	Serge	737
3277	Serge	738
		739	if(ret != 0 )
4398	Serge	740	{
3277	Serge	741	dbgprintf("%s: i915_gem_object_set_to_cpu_domain failed\n", __FUNCTION__);
4371	Serge	742	goto err2;
		743	};
3277	Serge	744
		745
		746
		747
		748
		749
		750
		751	src_offset+= get_display_map();
		752	dst_offset = (u8*)mask->bo_map;
		753
		754
3290	Serge	755
3277	Serge	756
		757	{
		758	mask_seqno[slot] = os_display->mask_seqno;
		759
		760
		761
		762
		763	"movd %[slot], %%xmm6 \n"
		764	"punpckldq %%xmm6, %%xmm6 \n"
		765	"punpcklqdq %%xmm6, %%xmm6 \n"
		766	:: [slot] "m" (slot)
		767	:"xmm6");
		768
		769
		770	{
		771	int tmp_w = mask->width;
4398	Serge	772
3277	Serge	773
		774	u8* tmp_dst = dst_offset;
		775
		776
		777	dst_offset+= mask->bo_pitch;
		778
		779
		780	{
		781	__asm__ __volatile__ (
		782	"movdqu (%0), %%xmm0 \n"
		783	"movdqu 16(%0), %%xmm1 \n"
		784	"movdqu 32(%0), %%xmm2 \n"
		785	"movdqu 48(%0), %%xmm3 \n"
		786	"pcmpeqb %%xmm6, %%xmm0 \n"
		787	"pcmpeqb %%xmm6, %%xmm1 \n"
		788	"pcmpeqb %%xmm6, %%xmm2 \n"
		789	"pcmpeqb %%xmm6, %%xmm3 \n"
		790	"movdqa %%xmm0, (%%edi) \n"
		791	"movdqa %%xmm1, 16(%%edi) \n"
		792	"movdqa %%xmm2, 32(%%edi) \n"
		793	"movdqa %%xmm3, 48(%%edi) \n"
		794
		795
		796	:"xmm0","xmm1","xmm2","xmm3");
		797	tmp_w -= 64;
		798	tmp_src += 64;
		799	tmp_dst += 64;
		800	}
		801
		802
		803	{
		804	__asm__ __volatile__ (
		805	"movdqu (%0), %%xmm0 \n"
		806	"movdqu 16(%0), %%xmm1 \n"
		807	"pcmpeqb %%xmm6, %%xmm0 \n"
		808	"pcmpeqb %%xmm6, %%xmm1 \n"
		809	"movdqa %%xmm0, (%%edi) \n"
		810	"movdqa %%xmm1, 16(%%edi) \n"
		811
		812
		813	:"xmm0","xmm1");
		814	tmp_w -= 32;
		815	tmp_src += 32;
		816	tmp_dst += 32;
		817	}
		818
		819
4398	Serge	820	{
3277	Serge	821	__asm__ __volatile__ (
		822	"movdqu (%0), %%xmm0 \n"
		823	"pcmpeqb %%xmm6, %%xmm0 \n"
		824	"movdqa %%xmm0, (%%edi) \n"
		825	:: "r" (tmp_src), "D" (tmp_dst)
		826	:"xmm0");
		827	tmp_w -= 16;
		828	tmp_src += 16;
		829	tmp_dst += 16;
		830	}
		831
4398	Serge	832
		833	{
		834	__asm__ __volatile__ (
		835	"movq (%0), %%xmm0 \n"
		836	"pcmpeqb %%xmm6, %%xmm0 \n"
		837	"movq %%xmm0, (%%edi) \n"
		838	:: "r" (tmp_src), "D" (tmp_dst)
		839	:"xmm0");
		840	tmp_w -= 8;
		841	tmp_src += 8;
		842	tmp_dst += 8;
		843	}
		844	if( tmp_w >= 4 )
		845	{
		846	__asm__ __volatile__ (
		847	"movd (%0), %%xmm0 \n"
		848	"pcmpeqb %%xmm6, %%xmm0 \n"
		849	"movd %%xmm0, (%%edi) \n"
		850	:: "r" (tmp_src), "D" (tmp_dst)
		851	:"xmm0");
		852	tmp_w -= 4;
		853	tmp_src += 4;
		854	tmp_dst += 4;
		855	}
		856	while(tmp_w--)
		857	tmp_dst++ = (tmp_src++ == (u8)slot) ? 0xFF:0x00;
		858	};
3277	Serge	859	};
		860	safe_sti(ifl);
		861
4371	Serge	862
		863	}
4539	Serge	864
		865
		866	mutex_unlock(&dev->struct_mutex);
		867	err1:
		868	drm_gem_object_unreference(obj);
		869
		870
		871	}
		872
		873
		874	struct drm_file *file)
		875	{
		876	struct drm_i915_mask_update *mask = data;
		877	struct drm_gem_object *obj;
		878	static unsigned int mask_seqno[256];
		879	static warn_count;
		880
		881
		882	u32 winw,winh;
		883	u32 ml,mt,mr,mb;
		884	u32 slot;
		885	int ret = 0;
		886	slot = ((u8)CURRENT_TASK);
		887
		888
		889	return 0;
		890
		891
		892	win.right+= 1;
		893	win.bottom+= 1;
		894
		895
		896	winh = win.bottom - win.top;
		897
		898
		899	mask->dy >= winh)
		900	return 1;
		901
		902
		903	mt = win.top + mask->dy;
		904	mr = ml + mask->width;
		905	mb = mt + mask->height;
		906
		907
		908	mr < win.left \|\| mb < win.top )
		909	return 1;
		910
		911
		912	mr = win.right;
		913
		914
		915	mb = win.bottom;
		916
		917
		918	mask->height = mb - mt;
		919
		920
		921	mask->height== 0 )
		922	return 1;
		923
		924
		925	if (obj == NULL)
		926	return -ENOENT;
		927
		928
		929	drm_gem_object_unreference_unlocked(obj);
		930	return -EINVAL;
		931	}
		932
		933
		934	if(warn_count < 1000)
		935	{
		936	printf("left %d top %d right %d bottom %d\n",
		937	ml, mt, mr, mb);
		938	warn_count++;
		939	};
		940	#endif
		941
		942
		943
		944
		945
		946	u8* src_offset;
		947	u8* dst_offset;
		948	u32 ifl;
		949
		950
		951	if (ret)
		952	goto err1;
		953
		954
		955
		956
		957	src_offset+= get_display_map();
		958	dst_offset = (u8*)mask->bo_map;
		959
		960
		961
		962
		963	{
4371	Serge	964	mask_seqno[slot] = os_display->mask_seqno;
4539	Serge	965
		966
		967
		968
		969	"movd %[slot], %%xmm6 \n"
		970	"punpckldq %%xmm6, %%xmm6 \n"
		971	"punpcklqdq %%xmm6, %%xmm6 \n"
		972	:: [slot] "m" (slot)
		973	:"xmm6");
		974
		975
		976	{
		977	int tmp_w = mask->width;
		978
		979
		980	u8* tmp_dst = dst_offset;
		981
		982
		983	dst_offset+= mask->bo_pitch;
		984
		985
		986	{
		987	__asm__ __volatile__ (
		988	"movdqu (%0), %%xmm0 \n"
		989	"movdqu 16(%0), %%xmm1 \n"
		990	"movdqu 32(%0), %%xmm2 \n"
		991	"movdqu 48(%0), %%xmm3 \n"
		992	"pcmpeqb %%xmm6, %%xmm0 \n"
		993	"pcmpeqb %%xmm6, %%xmm1 \n"
		994	"pcmpeqb %%xmm6, %%xmm2 \n"
		995	"pcmpeqb %%xmm6, %%xmm3 \n"
		996	"movdqa %%xmm0, (%%edi) \n"
		997	"movdqa %%xmm1, 16(%%edi) \n"
		998	"movdqa %%xmm2, 32(%%edi) \n"
		999	"movdqa %%xmm3, 48(%%edi) \n"
		1000
		1001
		1002	:"xmm0","xmm1","xmm2","xmm3");
		1003	tmp_w -= 64;
		1004	tmp_src += 64;
		1005	tmp_dst += 64;
		1006	}
		1007
		1008
		1009	{
		1010	__asm__ __volatile__ (
		1011	"movdqu (%0), %%xmm0 \n"
		1012	"movdqu 16(%0), %%xmm1 \n"
		1013	"pcmpeqb %%xmm6, %%xmm0 \n"
		1014	"pcmpeqb %%xmm6, %%xmm1 \n"
		1015	"movdqa %%xmm0, (%%edi) \n"
		1016	"movdqa %%xmm1, 16(%%edi) \n"
		1017
		1018
		1019	:"xmm0","xmm1");
		1020	tmp_w -= 32;
		1021	tmp_src += 32;
		1022	tmp_dst += 32;
		1023	}
		1024
		1025
		1026	{
		1027	__asm__ __volatile__ (
		1028	"movdqu (%0), %%xmm0 \n"
		1029	"pcmpeqb %%xmm6, %%xmm0 \n"
		1030	"movdqa %%xmm0, (%%edi) \n"
		1031	:: "r" (tmp_src), "D" (tmp_dst)
		1032	:"xmm0");
		1033	tmp_w -= 16;
		1034	tmp_src += 16;
		1035	tmp_dst += 16;
		1036	}
		1037
		1038
		1039	{
		1040	__asm__ __volatile__ (
		1041	"movq (%0), %%xmm0 \n"
		1042	"pcmpeqb %%xmm6, %%xmm0 \n"
		1043	"movq %%xmm0, (%%edi) \n"
		1044	:: "r" (tmp_src), "D" (tmp_dst)
		1045	:"xmm0");
		1046	tmp_w -= 8;
		1047	tmp_src += 8;
		1048	tmp_dst += 8;
		1049	}
		1050	if( tmp_w >= 4 )
		1051	{
		1052	__asm__ __volatile__ (
		1053	"movd (%0), %%xmm0 \n"
		1054	"pcmpeqb %%xmm6, %%xmm0 \n"
		1055	"movd %%xmm0, (%%edi) \n"
		1056	:: "r" (tmp_src), "D" (tmp_dst)
		1057	:"xmm0");
		1058	tmp_w -= 4;
		1059	tmp_src += 4;
		1060	tmp_dst += 4;
		1061	}
		1062	while(tmp_w--)
		1063	tmp_dst++ = (tmp_src++ == (u8)slot) ? 0xFF:0x00;
		1064	};
		1065	};
4371	Serge	1066	safe_sti(ifl);
4539	Serge	1067
		1068
		1069	}
3277	Serge	1070	#endif
4539	Serge	1071
3277	Serge	1072
4371	Serge	1073	mutex_unlock(&dev->struct_mutex);
		1074	err1:
		1075	drm_gem_object_unreference(obj);
3277	Serge	1076
		1077
4371	Serge	1078	}
3277	Serge	1079
		1080
		1081
		1082
2360	Serge	1083
		1084
		1085
		1086
		1087
		1088
		1089
		1090
3031	serge	1091
2360	Serge	1092
3031	serge	1093	{
		1094	u32 tmp = GetTimerTicks();
		1095
2360	Serge	1096
3031	serge	1097	ts->tv_nsec = (tmp - ts->tv_sec100)10000000;
		1098	}
		1099
2360	Serge	1100
4104	Serge	1101	{
3031	serge	1102	while (nsec >= NSEC_PER_SEC) {
4104	Serge	1103	/*
		1104	* The following asm() prevents the compiler from
		1105	* optimising this loop into a modulo operation. See
		1106	* also __iter_div_u64_rem() in include/linux/time.h
		1107	*/
		1108	asm("" : "+rm"(nsec));
		1109	nsec -= NSEC_PER_SEC;
		1110	++sec;
		1111	}
		1112	while (nsec < 0) {
		1113	asm("" : "+rm"(nsec));
		1114	nsec += NSEC_PER_SEC;
		1115	--sec;
		1116	}
		1117	ts->tv_sec = sec;
		1118	ts->tv_nsec = nsec;
		1119	}
3031	serge	1120
2360	Serge	1121
3480	Serge	1122	prepare_to_wait(wait_queue_head_t q, wait_queue_t wait, int state)
		1123	{
		1124	unsigned long flags;
		1125
3031	serge	1126
3480	Serge	1127	spin_lock_irqsave(&q->lock, flags);
		1128	if (list_empty(&wait->task_list))
		1129	__add_wait_queue(q, wait);
		1130	spin_unlock_irqrestore(&q->lock, flags);
		1131	}
		1132
		1133
		1134	* finish_wait - clean up after waiting in a queue
		1135	* @q: waitqueue waited on
		1136	* @wait: wait descriptor
		1137	*
		1138	* Sets current thread back to running state and removes
		1139	* the wait descriptor from the given waitqueue if still
		1140	* queued.
		1141	*/
		1142	void finish_wait(wait_queue_head_t q, wait_queue_t wait)
		1143	{
		1144	unsigned long flags;
		1145
		1146
		1147	/*
		1148	* We can check for list emptiness outside the lock
		1149	* IFF:
		1150	* - we use the "careful" check that verifies both
		1151	* the next and prev pointers, so that there cannot
		1152	* be any half-pending updates in progress on other
		1153	* CPU's that we haven't seen yet (and that might
		1154	* still change the stack area.
		1155	* and
		1156	* - all other users take the lock (ie we can only
		1157	* have _one_ other CPU that looks at or modifies
		1158	* the list).
		1159	*/
		1160	if (!list_empty_careful(&wait->task_list)) {
		1161	spin_lock_irqsave(&q->lock, flags);
		1162	list_del_init(&wait->task_list);
		1163	spin_unlock_irqrestore(&q->lock, flags);
		1164	}
		1165
		1166
		1167	}
		1168
		1169
		1170	{
		1171	list_del_init(&wait->task_list);
		1172	return 1;
		1173	}
		1174
		1175
3482	Serge	1176	{
		1177	unsigned int res = w - ((w >> 1) & 0x5555);
		1178	res = (res & 0x3333) + ((res >> 2) & 0x3333);
		1179	res = (res + (res >> 4)) & 0x0F0F;
		1180	return (res + (res >> 8)) & 0x00FF;
		1181	}
		1182
3480	Serge	1183
		1184
3482	Serge	1185	{
		1186	unsigned long j0 = GetTimerTicks();
		1187
3480	Serge	1188
3482	Serge	1189	return round_jiffies_common(j + j0, true) - j0;
		1190	}
		1191
3480	Serge	1192
3482	Serge	1193

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/i915/kms_display.c – Rev 4557