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

Rev	Author	Line No.	Line
3031	serge	1	#include
		2	#include
		3	#include
2338	Serge	4	#include "i915_drv.h"
3031	serge	5	//#include "intel_drv.h"
2338	Serge	6
2325	Serge	7	#include
		8	#include
		9	#include
		10	#include
		11	#include
		12	#include
		13
2342	Serge	14	#include "bitmap.h"
2340	Serge	15
3255	Serge	16	struct pci_device {
		17	uint16_t domain;
		18	uint8_t bus;
		19	uint8_t dev;
		20	uint8_t func;
		21	uint16_t vendor_id;
		22	uint16_t device_id;
		23	uint16_t subvendor_id;
		24	uint16_t subdevice_id;
		25	uint32_t device_class;
		26	uint8_t revision;
		27	};
		28
4104	Serge	29	struct drm_device *main_device;
		30	struct drm_file *drm_file_handlers[256];
4280	Serge	31	videomode_t usermode;
3033	serge	32
2344	Serge	33	void cpu_detect();
		34
2338	Serge	35	int _stdcall display_handler(ioctl_t *io);
2325	Serge	36	int init_agp(void);
		37
3120	serge	38	int srv_blit_bitmap(u32 hbitmap, int dst_x, int dst_y,
2351	Serge	39	int src_x, int src_y, u32 w, u32 h);
2340	Serge	40
2351	Serge	41	int blit_textured(u32 hbitmap, int dst_x, int dst_y,
		42	int src_x, int src_y, u32 w, u32 h);
		43
2361	Serge	44	int blit_tex(u32 hbitmap, int dst_x, int dst_y,
		45	int src_x, int src_y, u32 w, u32 h);
		46
3255	Serge	47	void get_pci_info(struct pci_device *dev);
4246	Serge	48	int i915_getparam(struct drm_device dev, void data,
		49	struct drm_file *file_priv);
3255	Serge	50
3277	Serge	51	int i915_mask_update(struct drm_device dev, void data,
		52	struct drm_file *file);
3255	Serge	53
4280	Serge	54	struct cmdtable cmdtable[]= {
		55	CMDENTRY("-pm=", i915_powersave),
		56	CMDENTRY("-rc6=", i915_enable_rc6),
		57	CMDENTRY("-fbc=", i915_enable_fbc),
		58	CMDENTRY("-ppgt=", i915_enable_ppgtt),
		59	CMDENTRY("-pc8=", i915_enable_pc8),
		60	{NULL, 0}
		61	};
3277	Serge	62
4280	Serge	63
2325	Serge	64	static char log[256];
		65
3482	Serge	66	struct workqueue_struct *system_wq;
3764	Serge	67	int driver_wq_state;
3482	Serge	68
2344	Serge	69	int x86_clflush_size;
3482	Serge	70	unsigned int tsc_khz;
2344	Serge	71
2338	Serge	72	int i915_modeset = 1;
		73
4126	Serge	74	typedef union __attribute__((packed))
		75	{
		76	uint32_t val;
		77	struct
		78	{
		79	uint8_t state;
		80	uint8_t code;
		81	uint16_t ctrl_key;
		82	};
		83	}oskey_t;
		84
		85	static inline oskey_t get_key(void)
		86	{
		87	oskey_t val;
		88	asm volatile("int $0x40":"=a"(val):"a"(2));
		89	return val;
		90	};
		91
		92	void i915_dpms(struct drm_device *dev, int mode);
		93
		94	void i915_driver_thread()
		95	{
		96	struct drm_i915_private *dev_priv = main_device->dev_private;
		97	struct workqueue_struct *cwq = dev_priv->wq;
		98	static int dpms = 1;
		99	static int dpms_lock = 0;
		100	oskey_t key;
		101	unsigned long irqflags;
		102	int tmp;
		103
		104	printf("%s\n",__FUNCTION__);
		105
		106	asm volatile("int $0x40":"=a"(tmp):"a"(66),"b"(1),"c"(1));
		107	asm volatile("int $0x40":"=a"(tmp):"a"(66),"b"(4),"c"(0x46),"d"(0x330));
		108	asm volatile("int $0x40":"=a"(tmp):"a"(66),"b"(4),"c"(0xC6),"d"(0x330));
		109
		110	while(driver_wq_state != 0)
		111	{
		112	key = get_key();
		113
		114	if( (key.val != 1) && (key.state == 0x02))
		115	{
		116	if(key.code == 0x46 && dpms_lock == 0)
		117	{
		118	dpms_lock = 1;
		119	if(dpms == 1)
		120	{
		121	i915_dpms(main_device, DRM_MODE_DPMS_OFF);
		122	printf("dpms off\n");
		123	}
		124	else
		125	{
		126	i915_dpms(main_device, DRM_MODE_DPMS_ON);
		127	printf("dpms on\n");
		128	};
		129	dpms ^= 1;
		130	}
		131	else if(key.code == 0xC6)
		132	dpms_lock = 0;
		133	};
		134
		135	spin_lock_irqsave(&cwq->lock, irqflags);
		136
		137	while (!list_empty(&cwq->worklist))
		138	{
		139	struct work_struct *work = list_entry(cwq->worklist.next,
		140	struct work_struct, entry);
		141	work_func_t f = work->func;
		142	list_del_init(cwq->worklist.next);
		143
		144	spin_unlock_irqrestore(&cwq->lock, irqflags);
		145	f(work);
		146	spin_lock_irqsave(&cwq->lock, irqflags);
		147	}
		148
		149	spin_unlock_irqrestore(&cwq->lock, irqflags);
		150
		151	delay(1);
		152	};
		153
		154	asm volatile ("int $0x40"::"a"(-1));
		155	}
		156
3480	Serge	157	u32_t __attribute__((externally_visible)) drvEntry(int action, char *cmdline)
2325	Serge	158	{
4104	Serge	159	int err = 0;
2325	Serge	160
		161	if(action != 1)
3764	Serge	162	{
		163	driver_wq_state = 0;
2325	Serge	164	return 0;
3764	Serge	165	};
2325	Serge	166
		167	if( GetService("DISPLAY") != 0 )
		168	return 0;
		169
4280	Serge	170	printf("i915 v3.12\n\nusage: i915 [options]\n"
		171	"-pm=<0,1> Enable powersavings, fbc, downclocking, etc. (default: 0 - false)\n");
		172	printf("-rc6=<-1,0-7> Enable power-saving render C-state 6.\n"
		173	" Different stages can be selected via bitmask values\n"
		174	" (0 = disable; 1 = enable rc6; 2 = enable deep rc6; 4 = enable deepest rc6).\n"
		175	" For example, 3 would enable rc6 and deep rc6, and 7 would enable everything.\n"
		176	" default: -1 (use per-chip default)\n");
		177	printf("-fbc=<-1,0,1> Enable frame buffer compression for power savings\n"
		178	" (default: 0 - false)\n");
		179	printf("-ppgt=<0,1> Enable PPGTT (default: 0 - false)\n");
		180	printf("-pc8=<0,1> Enable support for low power package C states (PC8+) (default: 0 - false)\n");
		181	printf("-l path to log file\n");
		182	printf("-m set videomode\n");
		183
2340	Serge	184	if( cmdline && *cmdline )
4280	Serge	185	parse_cmdline(cmdline, cmdtable, log, &usermode);
2325	Serge	186
		187	if(!dbg_open(log))
		188	{
4126	Serge	189	strcpy(log, "/tmp1/1/i915.log");
2325	Serge	190
		191	if(!dbg_open(log))
		192	{
		193	printf("Can't open %s\nExit\n", log);
		194	return 0;
		195	};
		196	}
		197
2351	Serge	198	cpu_detect();
3480	Serge	199	// dbgprintf("\ncache line size %d\n", x86_clflush_size);
2351	Serge	200
2325	Serge	201	enum_pci_devices();
		202
		203	err = i915_init();
2338	Serge	204	if(err)
		205	{
3298	Serge	206	dbgprintf("Epic Fail :(\n");
		207	return 0;
2338	Serge	208	};
2325	Serge	209
4280	Serge	210	init_display_kms(main_device, &usermode);
		211
2338	Serge	212	err = RegService("DISPLAY", display_handler);
2325	Serge	213
2338	Serge	214	if( err != 0)
		215	dbgprintf("Set DISPLAY handler\n");
		216
3764	Serge	217	driver_wq_state = 1;
4104	Serge	218
4126	Serge	219	CreateKernelThread(i915_driver_thread);
3482	Serge	220
2325	Serge	221	return err;
		222	};
		223
3480	Serge	224
2344	Serge	225	#define CURRENT_API 0x0200 /* 2.00 */
		226	#define COMPATIBLE_API 0x0100 /* 1.00 */
2338	Serge	227
2344	Serge	228	#define API_VERSION (COMPATIBLE_API << 16) \| CURRENT_API
2351	Serge	229	#define DISPLAY_VERSION API_VERSION
2338	Serge	230
		231
2352	Serge	232	#define SRV_GETVERSION 0
		233	#define SRV_ENUM_MODES 1
		234	#define SRV_SET_MODE 2
		235	#define SRV_GET_CAPS 3
2342	Serge	236
2352	Serge	237	#define SRV_CREATE_SURFACE 10
		238	#define SRV_DESTROY_SURFACE 11
		239	#define SRV_LOCK_SURFACE 12
		240	#define SRV_UNLOCK_SURFACE 13
3039	serge	241	#define SRV_RESIZE_SURFACE 14
3120	serge	242	#define SRV_BLIT_BITMAP 15
		243	#define SRV_BLIT_TEXTURE 16
		244	#define SRV_BLIT_VIDEO 17
2344	Serge	245
3290	Serge	246
3260	Serge	247	#define SRV_GET_PCI_INFO 20
4246	Serge	248	#define SRV_I915_GET_PARAM 21
4104	Serge	249	#define SRV_I915_GEM_CREATE 22
		250	#define SRV_DRM_GEM_CLOSE 23
4246	Serge	251	#define SRV_DRM_GEM_FLINK 24
		252	#define SRV_DRM_GEM_OPEN 25
		253	#define SRV_I915_GEM_PIN 26
		254	#define SRV_I915_GEM_UNPIN 27
		255	#define SRV_I915_GEM_SET_CACHING 28
		256	#define SRV_I915_GEM_PWRITE 29
		257	#define SRV_I915_GEM_BUSY 30
		258	#define SRV_I915_GEM_SET_DOMAIN 31
		259	#define SRV_I915_GEM_MMAP 32
		260	#define SRV_I915_GEM_SET_TILING 33
		261	#define SRV_I915_GEM_GET_TILING 34
		262	#define SRV_I915_GEM_GET_APERTURE 35
		263	#define SRV_I915_GEM_MMAP_GTT 36
		264	#define SRV_I915_GEM_THROTTLE 37
		265	#define SRV_I915_GEM_EXECBUFFER2 38
		266	#define SRV_I915_GEM_WAIT 39
		267	#define SRV_I915_GEM_CONTEXT_CREATE 40
		268	#define SRV_I915_GEM_CONTEXT_DESTROY 41
		269	#define SRV_I915_REG_READ 42
3260	Serge	270
4246	Serge	271	#define SRV_FBINFO 43
		272	#define SRV_MASK_UPDATE 44
3263	Serge	273
		274
2338	Serge	275	#define check_input(size) \
		276	if( unlikely((inp==NULL)\|\|(io->inp_size != (size))) ) \
		277	break;
		278
		279	#define check_output(size) \
		280	if( unlikely((outp==NULL)\|\|(io->out_size != (size))) ) \
		281	break;
		282
		283	int _stdcall display_handler(ioctl_t *io)
		284	{
3255	Serge	285	struct drm_file *file;
		286
2338	Serge	287	int retval = -1;
		288	u32_t *inp;
		289	u32_t *outp;
		290
		291	inp = io->input;
		292	outp = io->output;
		293
3255	Serge	294	file = drm_file_handlers[0];
		295
2338	Serge	296	switch(io->io_code)
		297	{
		298	case SRV_GETVERSION:
		299	check_output(4);
2344	Serge	300	*outp = DISPLAY_VERSION;
2338	Serge	301	retval = 0;
		302	break;
		303
		304	case SRV_ENUM_MODES:
3031	serge	305	// dbgprintf("SRV_ENUM_MODES inp %x inp_size %x out_size %x\n",
		306	// inp, io->inp_size, io->out_size );
2340	Serge	307	check_output(4);
2338	Serge	308	// check_input(outp sizeof(videomode_t));
		309	if( i915_modeset)
		310	retval = get_videomodes((videomode_t*)inp, outp);
		311	break;
		312
		313	case SRV_SET_MODE:
3031	serge	314	// dbgprintf("SRV_SET_MODE inp %x inp_size %x\n",
		315	// inp, io->inp_size);
2338	Serge	316	check_input(sizeof(videomode_t));
		317	if( i915_modeset )
		318	retval = set_user_mode((videomode_t*)inp);
		319	break;
3033	serge	320
2351	Serge	321	case SRV_GET_CAPS:
		322	retval = get_driver_caps((hwcaps_t*)inp);
		323	break;
		324
2344	Serge	325	case SRV_CREATE_SURFACE:
		326	// check_input(8);
3243	Serge	327	// retval = create_surface(main_device, (struct io_call_10*)inp);
2338	Serge	328	break;
		329
2352	Serge	330	case SRV_LOCK_SURFACE:
3243	Serge	331	// retval = lock_surface((struct io_call_12*)inp);
2352	Serge	332	break;
2342	Serge	333
3039	serge	334	case SRV_RESIZE_SURFACE:
3243	Serge	335	// retval = resize_surface((struct io_call_14*)inp);
3039	serge	336	break;
		337
3255	Serge	338	case SRV_BLIT_BITMAP:
3243	Serge	339	// srv_blit_bitmap( inp[0], inp[1], inp[2],
		340	// inp[3], inp[4], inp[5], inp[6]);
3033	serge	341
		342	// blit_tex( inp[0], inp[1], inp[2],
2351	Serge	343	// inp[3], inp[4], inp[5], inp[6]);
		344
3255	Serge	345	break;
2338	Serge	346
3260	Serge	347	case SRV_GET_PCI_INFO:
3255	Serge	348	get_pci_info((struct pci_device *)inp);
2338	Serge	349	retval = 0;
		350	break;
3031	serge	351
4246	Serge	352	case SRV_I915_GET_PARAM:
		353	retval = i915_getparam(main_device, inp, file);
3255	Serge	354	break;
		355
		356	case SRV_I915_GEM_CREATE:
		357	retval = i915_gem_create_ioctl(main_device, inp, file);
		358	break;
		359
		360	case SRV_DRM_GEM_CLOSE:
		361	retval = drm_gem_close_ioctl(main_device, inp, file);
		362	break;
		363
4246	Serge	364	case SRV_DRM_GEM_FLINK:
		365	retval = drm_gem_flink_ioctl(main_device, inp, file);
		366	break;
		367
		368	case SRV_DRM_GEM_OPEN:
		369	retval = drm_gem_open_ioctl(main_device, inp, file);
		370	break;
		371
3255	Serge	372	case SRV_I915_GEM_PIN:
		373	retval = i915_gem_pin_ioctl(main_device, inp, file);
		374	break;
3260	Serge	375
4246	Serge	376	case SRV_I915_GEM_UNPIN:
		377	retval = i915_gem_unpin_ioctl(main_device, inp, file);
3260	Serge	378	break;
		379
4246	Serge	380	case SRV_I915_GEM_SET_CACHING:
		381	retval = i915_gem_set_caching_ioctl(main_device, inp, file);
3260	Serge	382	break;
		383
		384	case SRV_I915_GEM_PWRITE:
		385	retval = i915_gem_pwrite_ioctl(main_device, inp, file);
		386	break;
		387
		388	case SRV_I915_GEM_BUSY:
		389	retval = i915_gem_busy_ioctl(main_device, inp, file);
		390	break;
		391
		392	case SRV_I915_GEM_SET_DOMAIN:
		393	retval = i915_gem_set_domain_ioctl(main_device, inp, file);
		394	break;
		395
3263	Serge	396	case SRV_I915_GEM_MMAP:
		397	retval = i915_gem_mmap_ioctl(main_device, inp, file);
		398	break;
		399
4246	Serge	400	case SRV_I915_GEM_SET_TILING:
		401	retval = i915_gem_set_tiling(main_device, inp, file);
		402	break;
		403
		404	case SRV_I915_GEM_GET_TILING:
		405	retval = i915_gem_get_tiling(main_device, inp, file);
		406	break;
		407
		408	case SRV_I915_GEM_GET_APERTURE:
		409	// printf("SRV_I915_GEM_GET_APERTURE ");
		410	retval = i915_gem_get_aperture_ioctl(main_device, inp, file);
		411	// printf(" retval=%d\n", retval);
		412	break;
		413
3480	Serge	414	case SRV_I915_GEM_MMAP_GTT:
		415	retval = i915_gem_mmap_gtt_ioctl(main_device, inp, file);
		416	break;
		417
4246	Serge	418	case SRV_I915_GEM_THROTTLE:
		419	retval = i915_gem_throttle_ioctl(main_device, inp, file);
3263	Serge	420	break;
		421
		422	case SRV_I915_GEM_EXECBUFFER2:
4246	Serge	423	// printf("SRV_I915_GEM_EXECBUFFER2\n");
3263	Serge	424	retval = i915_gem_execbuffer2(main_device, inp, file);
		425	break;
		426
4246	Serge	427	case SRV_I915_GEM_WAIT:
		428	retval = i915_gem_wait_ioctl(main_device, inp, file);
		429	break;
		430
		431	case SRV_I915_GEM_CONTEXT_CREATE:
		432	retval = i915_gem_context_create_ioctl(main_device, inp, file);
		433	break;
		434
		435	case SRV_I915_GEM_CONTEXT_DESTROY:
		436	retval = i915_gem_context_destroy_ioctl(main_device, inp, file);
		437	break;
		438
		439	case SRV_I915_REG_READ:
		440	retval = i915_reg_read_ioctl(main_device, inp, file);
		441	break;
		442
		443	case SRV_FBINFO:
		444	retval = i915_fbinfo(inp);
		445	break;
		446
3290	Serge	447	case SRV_MASK_UPDATE:
		448	retval = i915_mask_update(main_device, inp, file);
		449	break;
2338	Serge	450	};
		451
		452	return retval;
		453	}
		454
		455
2325	Serge	456	#define PCI_CLASS_REVISION 0x08
		457	#define PCI_CLASS_DISPLAY_VGA 0x0300
		458	#define PCI_CLASS_BRIDGE_HOST 0x0600
2326	Serge	459	#define PCI_CLASS_BRIDGE_ISA 0x0601
2325	Serge	460
		461	int pci_scan_filter(u32_t id, u32_t busnr, u32_t devfn)
		462	{
		463	u16_t vendor, device;
		464	u32_t class;
		465	int ret = 0;
		466
		467	vendor = id & 0xffff;
		468	device = (id >> 16) & 0xffff;
		469
		470	if(vendor == 0x8086)
		471	{
		472	class = PciRead32(busnr, devfn, PCI_CLASS_REVISION);
		473	class >>= 16;
		474
		475	if( (class == PCI_CLASS_DISPLAY_VGA) \|\|
2326	Serge	476	(class == PCI_CLASS_BRIDGE_HOST) \|\|
		477	(class == PCI_CLASS_BRIDGE_ISA))
2325	Serge	478	ret = 1;
		479	}
		480	return ret;
		481	};
2340	Serge	482
		483
		484
		485
2344	Serge	486	static inline void __cpuid(unsigned int eax, unsigned int ebx,
2351	Serge	487	unsigned int ecx, unsigned int edx)
2344	Serge	488	{
		489	/* ecx is often an input as well as an output. */
2351	Serge	490	asm volatile("cpuid"
2344	Serge	491	: "=a" (*eax),
		492	"=b" (*ebx),
		493	"=c" (*ecx),
		494	"=d" (*edx)
2351	Serge	495	: "0" (eax), "2" (ecx)
		496	: "memory");
2344	Serge	497	}
		498
2351	Serge	499
		500
2344	Serge	501	static inline void cpuid(unsigned int op,
		502	unsigned int eax, unsigned int ebx,
		503	unsigned int ecx, unsigned int edx)
		504	{
		505	*eax = op;
		506	*ecx = 0;
		507	__cpuid(eax, ebx, ecx, edx);
		508	}
		509
		510	void cpu_detect()
		511	{
		512	u32 junk, tfms, cap0, misc;
		513
		514	cpuid(0x00000001, &tfms, &misc, &junk, &cap0);
		515
		516	if (cap0 & (1<<19))
		517	{
		518	x86_clflush_size = ((misc >> 8) & 0xff) * 8;
		519	}
3482	Serge	520
		521	tsc_khz = (unsigned int)(GetCpuFreq()/1000);
2344	Serge	522	}
		523
3243	Serge	524
		525	int get_driver_caps(hwcaps_t *caps)
		526	{
		527	int ret = 0;
		528
		529	switch(caps->idx)
		530	{
		531	case 0:
		532	caps->opt[0] = 0;
		533	caps->opt[1] = 0;
		534	break;
		535
		536	case 1:
		537	caps->cap1.max_tex_width = 4096;
		538	caps->cap1.max_tex_height = 4096;
		539	break;
		540	default:
		541	ret = 1;
		542	};
		543	caps->idx = 1;
		544	return ret;
		545	}
		546
3255	Serge	547
		548	void get_pci_info(struct pci_device *dev)
		549	{
		550	struct pci_dev *pdev = main_device->pdev;
		551
		552	memset(dev, sizeof(*dev), 0);
		553
		554	dev->domain = 0;
		555	dev->bus = pdev->busnr;
		556	dev->dev = pdev->devfn >> 3;
		557	dev->func = pdev->devfn & 7;
		558	dev->vendor_id = pdev->vendor;
		559	dev->device_id = pdev->device;
		560	dev->revision = pdev->revision;
		561	};
4246	Serge	562
		563
		564
4280	Serge	565	char strstr(const char cs, const char *ct);
		566
		567	static int my_atoi(char **cmd)
		568	{
		569	char* p = *cmd;
		570	int val = 0;
		571	int sign = 1;
		572
		573	if(*p == '-')
		574	{
		575	sign = -1;
		576	p++;
		577	};
		578
		579	for (;; *p++) {
		580	switch (*p) {
		581	case '0' ... '9':
		582	val = 10val+(p-'0');
		583	break;
		584	default:
		585	*cmd = p;
		586	return val*sign;
		587	}
		588	}
		589	}
		590
		591	char* parse_mode(char p, videomode_t mode)
		592	{
		593	char c;
		594
		595	while( (c = *p++) == ' ');
		596
		597	if( c )
		598	{
		599	p--;
		600
		601	mode->width = my_atoi(&p);
		602	if(*p == 'x') p++;
		603
		604	mode->height = my_atoi(&p);
		605	if(*p == 'x') p++;
		606
		607	mode->bpp = 32;
		608
		609	mode->freq = my_atoi(&p);
		610
		611	if( mode->freq == 0 )
		612	mode->freq = 60;
		613	}
		614
		615	return p;
		616	};
		617
		618
		619	static char* parse_path(char p, char log)
		620	{
		621	char c;
		622
		623	while( (c = *p++) == ' ');
		624	p--;
		625	while( (c = log++ = p++) && (c != ' '));
		626	*log = 0;
		627
		628	return p;
		629	};
		630
		631	void parse_cmdline(char cmdline, struct cmdtable table, char log, videomode_t mode)
		632	{
		633	char *p = cmdline;
		634	char *p1;
		635	int val;
		636	char c = *p++;
		637
		638	if( table )
		639	{
		640	while(table->key)
		641	{
		642	if(p1 = strstr(cmdline, table->key))
		643	{
		644	p1+= table->size;
		645	*table->val = my_atoi(&p1);
		646	// printf("%s %d\n", table->key, *table->val);
		647	}
		648	table++;
		649	}
		650	}
		651
		652	while( c )
		653	{
		654	if( c == '-')
		655	{
		656	switch(*p++)
		657	{
		658	case 'l':
		659	p = parse_path(p, log);
		660	break;
		661
		662	case 'm':
		663	p = parse_mode(p, mode);
		664	break;
		665	};
		666	};
		667	c = *p++;
		668	};
		669	};
		670
		671	char strstr(const char cs, const char *ct)
		672	{
		673	int d0, d1;
		674	register char *__res;
		675	__asm__ __volatile__(
		676	"movl %6,%%edi\n\t"
		677	"repne\n\t"
		678	"scasb\n\t"
		679	"notl %%ecx\n\t"
		680	"decl %%ecx\n\t" /* NOTE! This also sets Z if searchstring='' */
		681	"movl %%ecx,%%edx\n"
		682	"1:\tmovl %6,%%edi\n\t"
		683	"movl %%esi,%%eax\n\t"
		684	"movl %%edx,%%ecx\n\t"
		685	"repe\n\t"
		686	"cmpsb\n\t"
		687	"je 2f\n\t" /* also works for empty string, see above */
		688	"xchgl %%eax,%%esi\n\t"
		689	"incl %%esi\n\t"
		690	"cmpb $0,-1(%%eax)\n\t"
		691	"jne 1b\n\t"
		692	"xorl %%eax,%%eax\n\t"
		693	"2:"
		694	: "=a" (__res), "=&c" (d0), "=&S" (d1)
		695	: "0" (0), "1" (0xffffffff), "2" (cs), "g" (ct)
		696	: "dx", "di");
		697	return __res;
		698	}

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/i915/main.c – Rev 4280