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

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

Subversion Repositories Kolibri OS

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