1	// SPDX-License-Identifier: GPL-2.0-only
2	/*
3	* A framebuffer driver for VBE 2.0+ compliant video cards
4	*
5	* (c) 2007 Michal Januszewski <spock@gentoo.org>
6	* Loosely based upon the vesafb driver.
7	*
8	*/
9
10	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
11
12	#include <linux/init.h>
13	#include <linux/module.h>
14	#include <linux/moduleparam.h>
15	#include <linux/skbuff.h>
16	#include <linux/timer.h>
17	#include <linux/completion.h>
18	#include <linux/connector.h>
19	#include <linux/random.h>
20	#include <linux/platform_device.h>
21	#include <linux/limits.h>
22	#include <linux/fb.h>
23	#include <linux/io.h>
24	#include <linux/mutex.h>
25	#include <linux/slab.h>
26	#include <video/edid.h>
27	#include <video/uvesafb.h>
28	#ifdef CONFIG_X86
29	#include <video/vga.h>
30	#endif
31	#include "edid.h"
32
33	static struct cb_id uvesafb_cn_id = {
34	.idx = CN_IDX_V86D,
35	.val = CN_VAL_V86D_UVESAFB
36	};
37	static char v86d_path[PATH_MAX] = "/sbin/v86d";
38	static char v86d_started; /* has v86d been started by uvesafb? */
39
40	static const struct fb_fix_screeninfo uvesafb_fix = {
41	.id = "VESA VGA",
42	.type = FB_TYPE_PACKED_PIXELS,
43	.accel = FB_ACCEL_NONE,
44	.visual = FB_VISUAL_TRUECOLOR,
45	};
46
47	static int mtrr = 3; /* enable mtrr by default */
48	static bool blank = true; /* enable blanking by default */
49	static int ypan = 1; /* 0: scroll, 1: ypan, 2: ywrap */
50	static bool pmi_setpal = true; /* use PMI for palette changes */
51	static bool nocrtc; /* ignore CRTC settings */
52	static bool noedid; /* don't try DDC transfers */
53	static int vram_remap; /* set amt. of memory to be used */
54	static int vram_total; /* set total amount of memory */
55	static u16 maxclk; /* maximum pixel clock */
56	static u16 maxvf; /* maximum vertical frequency */
57	static u16 maxhf; /* maximum horizontal frequency */
58	static u16 vbemode; /* force use of a specific VBE mode */
59	static char *mode_option;
60	static u8 dac_width = 6;
61
62	static struct uvesafb_ktask *uvfb_tasks[UVESAFB_TASKS_MAX];
63	static DEFINE_MUTEX(uvfb_lock);
64
65	/*
66	* A handler for replies from userspace.
67	*
68	* Make sure each message passes consistency checks and if it does,
69	* find the kernel part of the task struct, copy the registers and
70	* the buffer contents and then complete the task.
71	*/
72	static void uvesafb_cn_callback(struct cn_msg *msg, struct netlink_skb_parms *nsp)
73	{
74	struct uvesafb_task *utask;
75	struct uvesafb_ktask *task;
76
77	if (!capable(CAP_SYS_ADMIN))
78	return;
79
80	if (msg->seq >= UVESAFB_TASKS_MAX)
81	return;
82
83	mutex_lock(&uvfb_lock);
84	task = uvfb_tasks[msg->seq];
85
86	if (!task || msg->ack != task->ack) {
87	mutex_unlock(lock: &uvfb_lock);
88	return;
89	}
90
91	utask = (struct uvesafb_task *)msg->data;
92
93	/* Sanity checks for the buffer length. */
94	if (task->t.buf_len < utask->buf_len ||
95	utask->buf_len > msg->len - sizeof(*utask)) {
96	mutex_unlock(lock: &uvfb_lock);
97	return;
98	}
99
100	uvfb_tasks[msg->seq] = NULL;
101	mutex_unlock(lock: &uvfb_lock);
102
103	memcpy(&task->t, utask, sizeof(*utask));
104
105	if (task->t.buf_len && task->buf)
106	memcpy(task->buf, utask + 1, task->t.buf_len);
107
108	complete(task->done);
109	return;
110	}
111
112	static int uvesafb_helper_start(void)
113	{
114	char *envp[] = {
115	"HOME=/",
116	"PATH=/sbin:/bin",
117	NULL,
118	};
119
120	char *argv[] = {
121	v86d_path,
122	NULL,
123	};
124
125	return call_usermodehelper(path: v86d_path, argv, envp, UMH_WAIT_PROC);
126	}
127
128	/*
129	* Execute a uvesafb task.
130	*
131	* Returns 0 if the task is executed successfully.
132	*
133	* A message sent to the userspace consists of the uvesafb_task
134	* struct and (optionally) a buffer. The uvesafb_task struct is
135	* a simplified version of uvesafb_ktask (its kernel counterpart)
136	* containing only the register values, flags and the length of
137	* the buffer.
138	*
139	* Each message is assigned a sequence number (increased linearly)
140	* and a random ack number. The sequence number is used as a key
141	* for the uvfb_tasks array which holds pointers to uvesafb_ktask
142	* structs for all requests.
143	*/
144	static int uvesafb_exec(struct uvesafb_ktask *task)
145	{
146	static int seq;
147	struct cn_msg *m;
148	int err;
149	int len = sizeof(task->t) + task->t.buf_len;
150
151	/*
152	* Check whether the message isn't longer than the maximum
153	* allowed by connector.
154	*/
155	if (sizeof(*m) + len > CONNECTOR_MAX_MSG_SIZE) {
156	pr_warn("message too long (%d), can't execute task\n",
157	(int)(sizeof(*m) + len));
158	return -E2BIG;
159	}
160
161	m = kzalloc(size: sizeof(*m) + len, GFP_KERNEL);
162	if (!m)
163	return -ENOMEM;
164
165	init_completion(x: task->done);
166
167	memcpy(&m->id, &uvesafb_cn_id, sizeof(m->id));
168	m->seq = seq;
169	m->len = len;
170	m->ack = get_random_u32();
171
172	/* uvesafb_task structure */
173	memcpy(m + 1, &task->t, sizeof(task->t));
174
175	/* Buffer */
176	memcpy((u8 *)(m + 1) + sizeof(task->t), task->buf, task->t.buf_len);
177
178	/*
179	* Save the message ack number so that we can find the kernel
180	* part of this task when a reply is received from userspace.
181	*/
182	task->ack = m->ack;
183
184	mutex_lock(&uvfb_lock);
185
186	/* If all slots are taken -- bail out. */
187	if (uvfb_tasks[seq]) {
188	mutex_unlock(lock: &uvfb_lock);
189	err = -EBUSY;
190	goto out;
191	}
192
193	/* Save a pointer to the kernel part of the task struct. */
194	uvfb_tasks[seq] = task;
195	mutex_unlock(lock: &uvfb_lock);
196
197	err = cn_netlink_send(msg: m, portid: 0, group: 0, GFP_KERNEL);
198	if (err == -ESRCH) {
199	/*
200	* Try to start the userspace helper if sending
201	* the request failed the first time.
202	*/
203	err = uvesafb_helper_start();
204	if (err) {
205	pr_err("failed to execute %s\n", v86d_path);
206	pr_err("make sure that the v86d helper is installed and executable\n");
207	} else {
208	v86d_started = 1;
209	err = cn_netlink_send(msg: m, portid: 0, group: 0, gfp_mask: gfp_any());
210	if (err == -ENOBUFS)
211	err = 0;
212	}
213	} else if (err == -ENOBUFS)
214	err = 0;
215
216	if (!err && !(task->t.flags & TF_EXIT))
217	err = !wait_for_completion_timeout(x: task->done,
218	timeout: msecs_to_jiffies(UVESAFB_TIMEOUT));
219
220	mutex_lock(&uvfb_lock);
221	uvfb_tasks[seq] = NULL;
222	mutex_unlock(lock: &uvfb_lock);
223
224	seq++;
225	if (seq >= UVESAFB_TASKS_MAX)
226	seq = 0;
227	out:
228	kfree(objp: m);
229	return err;
230	}
231
232	/*
233	* Free a uvesafb_ktask struct.
234	*/
235	static void uvesafb_free(struct uvesafb_ktask *task)
236	{
237	if (task) {
238	kfree(objp: task->done);
239	kfree(objp: task);
240	}
241	}
242
243	/*
244	* Prepare a uvesafb_ktask struct to be used again.
245	*/
246	static void uvesafb_reset(struct uvesafb_ktask *task)
247	{
248	struct completion *cpl = task->done;
249
250	memset(task, 0, sizeof(*task));
251	task->done = cpl;
252	}
253
254	/*
255	* Allocate and prepare a uvesafb_ktask struct.
256	*/
257	static struct uvesafb_ktask *uvesafb_prep(void)
258	{
259	struct uvesafb_ktask *task;
260
261	task = kzalloc(size: sizeof(*task), GFP_KERNEL);
262	if (task) {
263	task->done = kzalloc(size: sizeof(*task->done), GFP_KERNEL);
264	if (!task->done) {
265	kfree(objp: task);
266	task = NULL;
267	}
268	}
269	return task;
270	}
271
272	static void uvesafb_setup_var(struct fb_var_screeninfo *var,
273	struct fb_info *info, struct vbe_mode_ib *mode)
274	{
275	struct uvesafb_par *par = info->par;
276
277	var->vmode = FB_VMODE_NONINTERLACED;
278	var->sync = FB_SYNC_VERT_HIGH_ACT;
279
280	var->xres = mode->x_res;
281	var->yres = mode->y_res;
282	var->xres_virtual = mode->x_res;
283	var->yres_virtual = (par->ypan) ?
284	info->fix.smem_len / mode->bytes_per_scan_line :
285	mode->y_res;
286	var->xoffset = 0;
287	var->yoffset = 0;
288	var->bits_per_pixel = mode->bits_per_pixel;
289
290	if (var->bits_per_pixel == 15)
291	var->bits_per_pixel = 16;
292
293	if (var->bits_per_pixel > 8) {
294	var->red.offset = mode->red_off;
295	var->red.length = mode->red_len;
296	var->green.offset = mode->green_off;
297	var->green.length = mode->green_len;
298	var->blue.offset = mode->blue_off;
299	var->blue.length = mode->blue_len;
300	var->transp.offset = mode->rsvd_off;
301	var->transp.length = mode->rsvd_len;
302	} else {
303	var->red.offset = 0;
304	var->green.offset = 0;
305	var->blue.offset = 0;
306	var->transp.offset = 0;
307
308	var->red.length = 8;
309	var->green.length = 8;
310	var->blue.length = 8;
311	var->transp.length = 0;
312	}
313	}
314
315	static int uvesafb_vbe_find_mode(struct uvesafb_par *par,
316	int xres, int yres, int depth, unsigned char flags)
317	{
318	int i, match = -1, h = 0, d = 0x7fffffff;
319
320	for (i = 0; i < par->vbe_modes_cnt; i++) {
321	h = abs(par->vbe_modes[i].x_res - xres) +
322	abs(par->vbe_modes[i].y_res - yres) +
323	abs(depth - par->vbe_modes[i].depth);
324
325	/*
326	* We have an exact match in terms of resolution
327	* and depth.
328	*/
329	if (h == 0)
330	return i;
331
332	if (h < d || (h == d && par->vbe_modes[i].depth > depth)) {
333	d = h;
334	match = i;
335	}
336	}
337	i = 1;
338
339	if (flags & UVESAFB_EXACT_DEPTH &&
340	par->vbe_modes[match].depth != depth)
341	i = 0;
342
343	if (flags & UVESAFB_EXACT_RES && d > 24)
344	i = 0;
345
346	if (i != 0)
347	return match;
348	else
349	return -1;
350	}
351
352	static u8 *uvesafb_vbe_state_save(struct uvesafb_par *par)
353	{
354	struct uvesafb_ktask *task;
355	u8 *state;
356	int err;
357
358	if (!par->vbe_state_size)
359	return NULL;
360
361	state = kmalloc(size: par->vbe_state_size, GFP_KERNEL);
362	if (!state)
363	return ERR_PTR(error: -ENOMEM);
364
365	task = uvesafb_prep();
366	if (!task) {
367	kfree(objp: state);
368	return NULL;
369	}
370
371	task->t.regs.eax = 0x4f04;
372	task->t.regs.ecx = 0x000f;
373	task->t.regs.edx = 0x0001;
374	task->t.flags = TF_BUF_RET | TF_BUF_ESBX;
375	task->t.buf_len = par->vbe_state_size;
376	task->buf = state;
377	err = uvesafb_exec(task);
378
379	if (err || (task->t.regs.eax & 0xffff) != 0x004f) {
380	pr_warn("VBE get state call failed (eax=0x%x, err=%d)\n",
381	task->t.regs.eax, err);
382	kfree(objp: state);
383	state = NULL;
384	}
385
386	uvesafb_free(task);
387	return state;
388	}
389
390	static void uvesafb_vbe_state_restore(struct uvesafb_par *par, u8 *state_buf)
391	{
392	struct uvesafb_ktask *task;
393	int err;
394
395	if (!state_buf)
396	return;
397
398	task = uvesafb_prep();
399	if (!task)
400	return;
401
402	task->t.regs.eax = 0x4f04;
403	task->t.regs.ecx = 0x000f;
404	task->t.regs.edx = 0x0002;
405	task->t.buf_len = par->vbe_state_size;
406	task->t.flags = TF_BUF_ESBX;
407	task->buf = state_buf;
408
409	err = uvesafb_exec(task);
410	if (err || (task->t.regs.eax & 0xffff) != 0x004f)
411	pr_warn("VBE state restore call failed (eax=0x%x, err=%d)\n",
412	task->t.regs.eax, err);
413
414	uvesafb_free(task);
415	}
416
417	static int uvesafb_vbe_getinfo(struct uvesafb_ktask *task,
418	struct uvesafb_par *par)
419	{
420	int err;
421
422	task->t.regs.eax = 0x4f00;
423	task->t.flags = TF_VBEIB;
424	task->t.buf_len = sizeof(struct vbe_ib);
425	task->buf = &par->vbe_ib;
426	memcpy(par->vbe_ib.vbe_signature, "VBE2", 4);
427
428	err = uvesafb_exec(task);
429	if (err || (task->t.regs.eax & 0xffff) != 0x004f) {
430	pr_err("Getting VBE info block failed (eax=0x%x, err=%d)\n",
431	(u32)task->t.regs.eax, err);
432	return -EINVAL;
433	}
434
435	if (par->vbe_ib.vbe_version < 0x0200) {
436	pr_err("Sorry, pre-VBE 2.0 cards are not supported\n");
437	return -EINVAL;
438	}
439
440	if (!par->vbe_ib.mode_list_ptr) {
441	pr_err("Missing mode list!\n");
442	return -EINVAL;
443	}
444
445	pr_info("");
446
447	/*
448	* Convert string pointers and the mode list pointer into
449	* usable addresses. Print informational messages about the
450	* video adapter and its vendor.
451	*/
452	if (par->vbe_ib.oem_vendor_name_ptr)
453	pr_cont("%s, ",
454	((char *)task->buf) + par->vbe_ib.oem_vendor_name_ptr);
455
456	if (par->vbe_ib.oem_product_name_ptr)
457	pr_cont("%s, ",
458	((char *)task->buf) + par->vbe_ib.oem_product_name_ptr);
459
460	if (par->vbe_ib.oem_product_rev_ptr)
461	pr_cont("%s, ",
462	((char *)task->buf) + par->vbe_ib.oem_product_rev_ptr);
463
464	if (par->vbe_ib.oem_string_ptr)
465	pr_cont("OEM: %s, ",
466	((char *)task->buf) + par->vbe_ib.oem_string_ptr);
467
468	pr_cont("VBE v%d.%d\n",
469	(par->vbe_ib.vbe_version & 0xff00) >> 8,
470	par->vbe_ib.vbe_version & 0xff);
471
472	return 0;
473	}
474
475	static int uvesafb_vbe_getmodes(struct uvesafb_ktask *task,
476	struct uvesafb_par *par)
477	{
478	int off = 0, err;
479	u16 *mode;
480
481	par->vbe_modes_cnt = 0;
482
483	/* Count available modes. */
484	mode = (u16 *) (((u8 *)&par->vbe_ib) + par->vbe_ib.mode_list_ptr);
485	while (*mode != 0xffff) {
486	par->vbe_modes_cnt++;
487	mode++;
488	}
489
490	par->vbe_modes = kcalloc(n: par->vbe_modes_cnt,
491	size: sizeof(struct vbe_mode_ib),
492	GFP_KERNEL);
493	if (!par->vbe_modes)
494	return -ENOMEM;
495
496	/* Get info about all available modes. */
497	mode = (u16 *) (((u8 *)&par->vbe_ib) + par->vbe_ib.mode_list_ptr);
498	while (*mode != 0xffff) {
499	struct vbe_mode_ib *mib;
500
501	uvesafb_reset(task);
502	task->t.regs.eax = 0x4f01;
503	task->t.regs.ecx = (u32) *mode;
504	task->t.flags = TF_BUF_RET | TF_BUF_ESDI;
505	task->t.buf_len = sizeof(struct vbe_mode_ib);
506	task->buf = par->vbe_modes + off;
507
508	err = uvesafb_exec(task);
509	if (err || (task->t.regs.eax & 0xffff) != 0x004f) {
510	pr_warn("Getting mode info block for mode 0x%x failed (eax=0x%x, err=%d)\n",
511	*mode, (u32)task->t.regs.eax, err);
512	mode++;
513	par->vbe_modes_cnt--;
514	continue;
515	}
516
517	mib = task->buf;
518	mib->mode_id = *mode;
519
520	/*
521	* We only want modes that are supported with the current
522	* hardware configuration, color, graphics and that have
523	* support for the LFB.
524	*/
525	if ((mib->mode_attr & VBE_MODE_MASK) == VBE_MODE_MASK &&
526	mib->bits_per_pixel >= 8)
527	off++;
528	else
529	par->vbe_modes_cnt--;
530
531	mode++;
532	mib->depth = mib->red_len + mib->green_len + mib->blue_len;
533
534	/*
535	* Handle 8bpp modes and modes with broken color component
536	* lengths.
537	*/
538	if (mib->depth == 0 || (mib->depth == 24 &&
539	mib->bits_per_pixel == 32))
540	mib->depth = mib->bits_per_pixel;
541	}
542
543	if (par->vbe_modes_cnt > 0)
544	return 0;
545	else
546	return -EINVAL;
547	}
548
549	/*
550	* The Protected Mode Interface is 32-bit x86 code, so we only run it on
551	* x86 and not x86_64.
552	*/
553	#ifdef CONFIG_X86_32
554	static int uvesafb_vbe_getpmi(struct uvesafb_ktask *task,
555	struct uvesafb_par *par)
556	{
557	int i, err;
558
559	uvesafb_reset(task);
560	task->t.regs.eax = 0x4f0a;
561	task->t.regs.ebx = 0x0;
562	err = uvesafb_exec(task);
563	if (err)
564	return err;
565
566	if ((task->t.regs.eax & 0xffff) != 0x4f || task->t.regs.es < 0xc000) {
567	par->pmi_setpal = par->ypan = 0;
568	} else {
569	par->pmi_base = (u16 *)phys_to_virt(((u32)task->t.regs.es << 4)
570	+ task->t.regs.edi);
571	par->pmi_start = (u8 *)par->pmi_base + par->pmi_base[1];
572	par->pmi_pal = (u8 *)par->pmi_base + par->pmi_base[2];
573	pr_info("protected mode interface info at %04x:%04x\n",
574	(u16)task->t.regs.es, (u16)task->t.regs.edi);
575	pr_info("pmi: set display start = %p, set palette = %p\n",
576	par->pmi_start, par->pmi_pal);
577
578	if (par->pmi_base[3]) {
579	pr_info("pmi: ports =");
580	for (i = par->pmi_base[3]/2;
581	par->pmi_base[i] != 0xffff; i++)
582	pr_cont(" %x", par->pmi_base[i]);
583	pr_cont("\n");
584
585	if (par->pmi_base[i] != 0xffff) {
586	pr_info("can't handle memory requests, pmi disabled\n");
587	par->ypan = par->pmi_setpal = 0;
588	}
589	}
590	}
591	return 0;
592	}
593	#endif /* CONFIG_X86_32 */
594
595	/*
596	* Check whether a video mode is supported by the Video BIOS and is
597	* compatible with the monitor limits.
598	*/
599	static int uvesafb_is_valid_mode(struct fb_videomode *mode,
600	struct fb_info *info)
601	{
602	if (info->monspecs.gtf) {
603	fb_videomode_to_var(var: &info->var, mode);
604	if (fb_validate_mode(var: &info->var, info))
605	return 0;
606	}
607
608	if (uvesafb_vbe_find_mode(par: info->par, xres: mode->xres, yres: mode->yres, depth: 8,
609	UVESAFB_EXACT_RES) == -1)
610	return 0;
611
612	return 1;
613	}
614
615	static int uvesafb_vbe_getedid(struct uvesafb_ktask *task, struct fb_info *info)
616	{
617	struct uvesafb_par *par = info->par;
618	int err = 0;
619
620	if (noedid || par->vbe_ib.vbe_version < 0x0300)
621	return -EINVAL;
622
623	task->t.regs.eax = 0x4f15;
624	task->t.regs.ebx = 0;
625	task->t.regs.ecx = 0;
626	task->t.buf_len = 0;
627	task->t.flags = 0;
628
629	err = uvesafb_exec(task);
630
631	if ((task->t.regs.eax & 0xffff) != 0x004f || err)
632	return -EINVAL;
633
634	if ((task->t.regs.ebx & 0x3) == 3) {
635	pr_info("VBIOS/hardware supports both DDC1 and DDC2 transfers\n");
636	} else if ((task->t.regs.ebx & 0x3) == 2) {
637	pr_info("VBIOS/hardware supports DDC2 transfers\n");
638	} else if ((task->t.regs.ebx & 0x3) == 1) {
639	pr_info("VBIOS/hardware supports DDC1 transfers\n");
640	} else {
641	pr_info("VBIOS/hardware doesn't support DDC transfers\n");
642	return -EINVAL;
643	}
644
645	task->t.regs.eax = 0x4f15;
646	task->t.regs.ebx = 1;
647	task->t.regs.ecx = task->t.regs.edx = 0;
648	task->t.flags = TF_BUF_RET | TF_BUF_ESDI;
649	task->t.buf_len = EDID_LENGTH;
650	task->buf = kzalloc(EDID_LENGTH, GFP_KERNEL);
651	if (!task->buf)
652	return -ENOMEM;
653
654	err = uvesafb_exec(task);
655
656	if ((task->t.regs.eax & 0xffff) == 0x004f && !err) {
657	fb_edid_to_monspecs(edid: task->buf, specs: &info->monspecs);
658
659	if (info->monspecs.vfmax && info->monspecs.hfmax) {
660	/*
661	* If the maximum pixel clock wasn't specified in
662	* the EDID block, set it to 300 MHz.
663	*/
664	if (info->monspecs.dclkmax == 0)
665	info->monspecs.dclkmax = 300 * 1000000;
666	info->monspecs.gtf = 1;
667	}
668	} else {
669	err = -EINVAL;
670	}
671
672	kfree(objp: task->buf);
673	return err;
674	}
675
676	static void uvesafb_vbe_getmonspecs(struct uvesafb_ktask *task,
677	struct fb_info *info)
678	{
679	struct uvesafb_par *par = info->par;
680	int i;
681
682	memset(&info->monspecs, 0, sizeof(info->monspecs));
683
684	/*
685	* If we don't get all necessary data from the EDID block,
686	* mark it as incompatible with the GTF and set nocrtc so
687	* that we always use the default BIOS refresh rate.
688	*/
689	if (uvesafb_vbe_getedid(task, info)) {
690	info->monspecs.gtf = 0;
691	par->nocrtc = 1;
692	}
693
694	/* Kernel command line overrides. */
695	if (maxclk)
696	info->monspecs.dclkmax = maxclk * 1000000;
697	if (maxvf)
698	info->monspecs.vfmax = maxvf;
699	if (maxhf)
700	info->monspecs.hfmax = maxhf * 1000;
701
702	/*
703	* In case DDC transfers are not supported, the user can provide
704	* monitor limits manually. Lower limits are set to "safe" values.
705	*/
706	if (info->monspecs.gtf == 0 && maxclk && maxvf && maxhf) {
707	info->monspecs.dclkmin = 0;
708	info->monspecs.vfmin = 60;
709	info->monspecs.hfmin = 29000;
710	info->monspecs.gtf = 1;
711	par->nocrtc = 0;
712	}
713
714	if (info->monspecs.gtf)
715	pr_info("monitor limits: vf = %d Hz, hf = %d kHz, clk = %d MHz\n",
716	info->monspecs.vfmax,
717	(int)(info->monspecs.hfmax / 1000),
718	(int)(info->monspecs.dclkmax / 1000000));
719	else
720	pr_info("no monitor limits have been set, default refresh rate will be used\n");
721
722	/* Add VBE modes to the modelist. */
723	for (i = 0; i < par->vbe_modes_cnt; i++) {
724	struct fb_var_screeninfo var;
725	struct vbe_mode_ib *mode;
726	struct fb_videomode vmode;
727
728	mode = &par->vbe_modes[i];
729	memset(&var, 0, sizeof(var));
730
731	var.xres = mode->x_res;
732	var.yres = mode->y_res;
733
734	fb_get_mode(FB_VSYNCTIMINGS | FB_IGNOREMON, val: 60, var: &var, info);
735	fb_var_to_videomode(mode: &vmode, var: &var);
736	fb_add_videomode(mode: &vmode, head: &info->modelist);
737	}
738
739	/* Add valid VESA modes to our modelist. */
740	for (i = 0; i < VESA_MODEDB_SIZE; i++) {
741	if (uvesafb_is_valid_mode(mode: (struct fb_videomode *)
742	&vesa_modes[i], info))
743	fb_add_videomode(mode: &vesa_modes[i], head: &info->modelist);
744	}
745
746	for (i = 0; i < info->monspecs.modedb_len; i++) {
747	if (uvesafb_is_valid_mode(mode: &info->monspecs.modedb[i], info))
748	fb_add_videomode(mode: &info->monspecs.modedb[i],
749	head: &info->modelist);
750	}
751
752	return;
753	}
754
755	static void uvesafb_vbe_getstatesize(struct uvesafb_ktask *task,
756	struct uvesafb_par *par)
757	{
758	int err;
759
760	uvesafb_reset(task);
761
762	/*
763	* Get the VBE state buffer size. We want all available
764	* hardware state data (CL = 0x0f).
765	*/
766	task->t.regs.eax = 0x4f04;
767	task->t.regs.ecx = 0x000f;
768	task->t.regs.edx = 0x0000;
769	task->t.flags = 0;
770
771	err = uvesafb_exec(task);
772
773	if (err || (task->t.regs.eax & 0xffff) != 0x004f) {
774	pr_warn("VBE state buffer size cannot be determined (eax=0x%x, err=%d)\n",
775	task->t.regs.eax, err);
776	par->vbe_state_size = 0;
777	return;
778	}
779
780	par->vbe_state_size = 64 * (task->t.regs.ebx & 0xffff);
781	}
782
783	static int uvesafb_vbe_init(struct fb_info *info)
784	{
785	struct uvesafb_ktask *task = NULL;
786	struct uvesafb_par *par = info->par;
787	int err;
788
789	task = uvesafb_prep();
790	if (!task)
791	return -ENOMEM;
792
793	err = uvesafb_vbe_getinfo(task, par);
794	if (err)
795	goto out;
796
797	err = uvesafb_vbe_getmodes(task, par);
798	if (err)
799	goto out;
800
801	par->nocrtc = nocrtc;
802	#ifdef CONFIG_X86_32
803	par->pmi_setpal = pmi_setpal;
804	par->ypan = ypan;
805
806	if (par->pmi_setpal || par->ypan) {
807	if (__supported_pte_mask & _PAGE_NX) {
808	par->pmi_setpal = par->ypan = 0;
809	pr_warn("NX protection is active, better not use the PMI\n");
810	} else {
811	uvesafb_vbe_getpmi(task, par);
812	}
813	}
814	#else
815	/* The protected mode interface is not available on non-x86. */
816	par->pmi_setpal = par->ypan = 0;
817	#endif
818
819	INIT_LIST_HEAD(list: &info->modelist);
820	uvesafb_vbe_getmonspecs(task, info);
821	uvesafb_vbe_getstatesize(task, par);
822
823	out: uvesafb_free(task);
824	return err;
825	}
826
827	static int uvesafb_vbe_init_mode(struct fb_info *info)
828	{
829	struct list_head *pos;
830	struct fb_modelist *modelist;
831	struct fb_videomode *mode;
832	struct uvesafb_par *par = info->par;
833	int i, modeid;
834
835	/* Has the user requested a specific VESA mode? */
836	if (vbemode) {
837	for (i = 0; i < par->vbe_modes_cnt; i++) {
838	if (par->vbe_modes[i].mode_id == vbemode) {
839	modeid = i;
840	uvesafb_setup_var(var: &info->var, info,
841	mode: &par->vbe_modes[modeid]);
842	fb_get_mode(FB_VSYNCTIMINGS | FB_IGNOREMON, val: 60,
843	var: &info->var, info);
844	/*
845	* With pixclock set to 0, the default BIOS
846	* timings will be used in set_par().
847	*/
848	info->var.pixclock = 0;
849	goto gotmode;
850	}
851	}
852	pr_info("requested VBE mode 0x%x is unavailable\n", vbemode);
853	vbemode = 0;
854	}
855
856	/* Count the modes in the modelist */
857	i = 0;
858	list_for_each(pos, &info->modelist)
859	i++;
860
861	/*
862	* Convert the modelist into a modedb so that we can use it with
863	* fb_find_mode().
864	*/
865	mode = kcalloc(n: i, size: sizeof(*mode), GFP_KERNEL);
866	if (mode) {
867	i = 0;
868	list_for_each(pos, &info->modelist) {
869	modelist = list_entry(pos, struct fb_modelist, list);
870	mode[i] = modelist->mode;
871	i++;
872	}
873
874	if (!mode_option)
875	mode_option = UVESAFB_DEFAULT_MODE;
876
877	i = fb_find_mode(var: &info->var, info, mode_option, db: mode, dbsize: i,
878	NULL, default_bpp: 8);
879
880	kfree(objp: mode);
881	}
882
883	/* fb_find_mode() failed */
884	if (i == 0) {
885	info->var.xres = 640;
886	info->var.yres = 480;
887	mode = (struct fb_videomode *)
888	fb_find_best_mode(var: &info->var, head: &info->modelist);
889
890	if (mode) {
891	fb_videomode_to_var(var: &info->var, mode);
892	} else {
893	modeid = par->vbe_modes[0].mode_id;
894	uvesafb_setup_var(var: &info->var, info,
895	mode: &par->vbe_modes[modeid]);
896	fb_get_mode(FB_VSYNCTIMINGS | FB_IGNOREMON, val: 60,
897	var: &info->var, info);
898
899	goto gotmode;
900	}
901	}
902
903	/* Look for a matching VBE mode. */
904	modeid = uvesafb_vbe_find_mode(par, xres: info->var.xres, yres: info->var.yres,
905	depth: info->var.bits_per_pixel, UVESAFB_EXACT_RES);
906
907	if (modeid == -1)
908	return -EINVAL;
909
910	uvesafb_setup_var(var: &info->var, info, mode: &par->vbe_modes[modeid]);
911
912	gotmode:
913	/*
914	* If we are not VBE3.0+ compliant, we're done -- the BIOS will
915	* ignore our timings anyway.
916	*/
917	if (par->vbe_ib.vbe_version < 0x0300 || par->nocrtc)
918	fb_get_mode(FB_VSYNCTIMINGS | FB_IGNOREMON, val: 60,
919	var: &info->var, info);
920
921	return modeid;
922	}
923
924	static int uvesafb_setpalette(struct uvesafb_pal_entry *entries, int count,
925	int start, struct fb_info *info)
926	{
927	struct uvesafb_ktask *task;
928	#ifdef CONFIG_X86
929	struct uvesafb_par *par = info->par;
930	int i = par->mode_idx;
931	#endif
932	int err = 0;
933
934	/*
935	* We support palette modifications for 8 bpp modes only, so
936	* there can never be more than 256 entries.
937	*/
938	if (start + count > 256)
939	return -EINVAL;
940
941	#ifdef CONFIG_X86
942	/* Use VGA registers if mode is VGA-compatible. */
943	if (i >= 0 && i < par->vbe_modes_cnt &&
944	par->vbe_modes[i].mode_attr & VBE_MODE_VGACOMPAT) {
945	for (i = 0; i < count; i++) {
946	outb_p(value: start + i, dac_reg);
947	outb_p(value: entries[i].red, dac_val);
948	outb_p(value: entries[i].green, dac_val);
949	outb_p(value: entries[i].blue, dac_val);
950	}
951	}
952	#ifdef CONFIG_X86_32
953	else if (par->pmi_setpal) {
954	__asm__ __volatile__(
955	"call *(%%esi)"
956	: /* no return value */
957	: "a" (0x4f09), /* EAX */
958	"b" (0), /* EBX */
959	"c" (count), /* ECX */
960	"d" (start), /* EDX */
961	"D" (entries), /* EDI */
962	"S" (&par->pmi_pal)); /* ESI */
963	}
964	#endif /* CONFIG_X86_32 */
965	else
966	#endif /* CONFIG_X86 */
967	{
968	task = uvesafb_prep();
969	if (!task)
970	return -ENOMEM;
971
972	task->t.regs.eax = 0x4f09;
973	task->t.regs.ebx = 0x0;
974	task->t.regs.ecx = count;
975	task->t.regs.edx = start;
976	task->t.flags = TF_BUF_ESDI;
977	task->t.buf_len = sizeof(struct uvesafb_pal_entry) * count;
978	task->buf = entries;
979
980	err = uvesafb_exec(task);
981	if ((task->t.regs.eax & 0xffff) != 0x004f)
982	err = 1;
983
984	uvesafb_free(task);
985	}
986	return err;
987	}
988
989	static int uvesafb_setcolreg(unsigned regno, unsigned red, unsigned green,
990	unsigned blue, unsigned transp,
991	struct fb_info *info)
992	{
993	struct uvesafb_pal_entry entry;
994	int shift = 16 - dac_width;
995	int err = 0;
996
997	if (regno >= info->cmap.len)
998	return -EINVAL;
999
1000	if (info->var.bits_per_pixel == 8) {
1001	entry.red = red >> shift;
1002	entry.green = green >> shift;
1003	entry.blue = blue >> shift;
1004	entry.pad = 0;
1005
1006	err = uvesafb_setpalette(entries: &entry, count: 1, start: regno, info);
1007	} else if (regno < 16) {
1008	switch (info->var.bits_per_pixel) {
1009	case 16:
1010	if (info->var.red.offset == 10) {
1011	/* 1:5:5:5 */
1012	((u32 *) (info->pseudo_palette))[regno] =
1013	((red & 0xf800) >> 1) |
1014	((green & 0xf800) >> 6) |
1015	((blue & 0xf800) >> 11);
1016	} else {
1017	/* 0:5:6:5 */
1018	((u32 *) (info->pseudo_palette))[regno] =
1019	((red & 0xf800) ) |
1020	((green & 0xfc00) >> 5) |
1021	((blue & 0xf800) >> 11);
1022	}
1023	break;
1024
1025	case 24:
1026	case 32:
1027	red >>= 8;
1028	green >>= 8;
1029	blue >>= 8;
1030	((u32 *)(info->pseudo_palette))[regno] =
1031	(red << info->var.red.offset) |
1032	(green << info->var.green.offset) |
1033	(blue << info->var.blue.offset);
1034	break;
1035	}
1036	}
1037	return err;
1038	}
1039
1040	static int uvesafb_setcmap(struct fb_cmap *cmap, struct fb_info *info)
1041	{
1042	struct uvesafb_pal_entry *entries;
1043	int shift = 16 - dac_width;
1044	int i, err = 0;
1045
1046	if (info->var.bits_per_pixel == 8) {
1047	if (cmap->start + cmap->len > info->cmap.start +
1048	info->cmap.len || cmap->start < info->cmap.start)
1049	return -EINVAL;
1050
1051	entries = kmalloc_array(n: cmap->len, size: sizeof(*entries),
1052	GFP_KERNEL);
1053	if (!entries)
1054	return -ENOMEM;
1055
1056	for (i = 0; i < cmap->len; i++) {
1057	entries[i].red = cmap->red[i] >> shift;
1058	entries[i].green = cmap->green[i] >> shift;
1059	entries[i].blue = cmap->blue[i] >> shift;
1060	entries[i].pad = 0;
1061	}
1062	err = uvesafb_setpalette(entries, count: cmap->len, start: cmap->start, info);
1063	kfree(objp: entries);
1064	} else {
1065	/*
1066	* For modes with bpp > 8, we only set the pseudo palette in
1067	* the fb_info struct. We rely on uvesafb_setcolreg to do all
1068	* sanity checking.
1069	*/
1070	for (i = 0; i < cmap->len; i++) {
1071	err |= uvesafb_setcolreg(regno: cmap->start + i, red: cmap->red[i],
1072	green: cmap->green[i], blue: cmap->blue[i],
1073	transp: 0, info);
1074	}
1075	}
1076	return err;
1077	}
1078
1079	static int uvesafb_pan_display(struct fb_var_screeninfo *var,
1080	struct fb_info *info)
1081	{
1082	#ifdef CONFIG_X86_32
1083	int offset;
1084	struct uvesafb_par *par = info->par;
1085
1086	offset = (var->yoffset * info->fix.line_length + var->xoffset) / 4;
1087
1088	/*
1089	* It turns out it's not the best idea to do panning via vm86,
1090	* so we only allow it if we have a PMI.
1091	*/
1092	if (par->pmi_start) {
1093	__asm__ __volatile__(
1094	"call *(%%edi)"
1095	: /* no return value */
1096	: "a" (0x4f07), /* EAX */
1097	"b" (0), /* EBX */
1098	"c" (offset), /* ECX */
1099	"d" (offset >> 16), /* EDX */
1100	"D" (&par->pmi_start)); /* EDI */
1101	}
1102	#endif
1103	return 0;
1104	}
1105
1106	static int uvesafb_blank(int blank, struct fb_info *info)
1107	{
1108	struct uvesafb_ktask *task;
1109	int err = 1;
1110	#ifdef CONFIG_X86
1111	struct uvesafb_par *par = info->par;
1112
1113	if (par->vbe_ib.capabilities & VBE_CAP_VGACOMPAT) {
1114	int loop = 10000;
1115	u8 seq = 0, crtc17 = 0;
1116
1117	if (blank == FB_BLANK_POWERDOWN) {
1118	seq = 0x20;
1119	crtc17 = 0x00;
1120	err = 0;
1121	} else {
1122	seq = 0x00;
1123	crtc17 = 0x80;
1124	err = (blank == FB_BLANK_UNBLANK) ? 0 : -EINVAL;
1125	}
1126
1127	vga_wseq(NULL, reg: 0x00, val: 0x01);
1128	seq |= vga_rseq(NULL, reg: 0x01) & ~0x20;
1129	vga_wseq(NULL, reg: 0x00, val: seq);
1130
1131	crtc17 |= vga_rcrt(NULL, reg: 0x17) & ~0x80;
1132	while (loop--);
1133	vga_wcrt(NULL, reg: 0x17, val: crtc17);
1134	vga_wseq(NULL, reg: 0x00, val: 0x03);
1135	} else
1136	#endif /* CONFIG_X86 */
1137	{
1138	task = uvesafb_prep();
1139	if (!task)
1140	return -ENOMEM;
1141
1142	task->t.regs.eax = 0x4f10;
1143	switch (blank) {
1144	case FB_BLANK_UNBLANK:
1145	task->t.regs.ebx = 0x0001;
1146	break;
1147	case FB_BLANK_NORMAL:
1148	task->t.regs.ebx = 0x0101; /* standby */
1149	break;
1150	case FB_BLANK_POWERDOWN:
1151	task->t.regs.ebx = 0x0401; /* powerdown */
1152	break;
1153	default:
1154	goto out;
1155	}
1156
1157	err = uvesafb_exec(task);
1158	if (err || (task->t.regs.eax & 0xffff) != 0x004f)
1159	err = 1;
1160	out: uvesafb_free(task);
1161	}
1162	return err;
1163	}
1164
1165	static int uvesafb_open(struct fb_info *info, int user)
1166	{
1167	struct uvesafb_par *par = info->par;
1168	int cnt = atomic_read(v: &par->ref_count);
1169	u8 *buf = NULL;
1170
1171	if (!cnt && par->vbe_state_size) {
1172	buf = uvesafb_vbe_state_save(par);
1173	if (IS_ERR(ptr: buf)) {
1174	pr_warn("save hardware state failed, error code is %ld!\n",
1175	PTR_ERR(buf));
1176	} else {
1177	par->vbe_state_orig = buf;
1178	}
1179	}
1180
1181	atomic_inc(v: &par->ref_count);
1182	return 0;
1183	}
1184
1185	static int uvesafb_release(struct fb_info *info, int user)
1186	{
1187	struct uvesafb_ktask *task = NULL;
1188	struct uvesafb_par *par = info->par;
1189	int cnt = atomic_read(v: &par->ref_count);
1190
1191	if (!cnt)
1192	return -EINVAL;
1193
1194	if (cnt != 1)
1195	goto out;
1196
1197	task = uvesafb_prep();
1198	if (!task)
1199	goto out;
1200
1201	/* First, try to set the standard 80x25 text mode. */
1202	task->t.regs.eax = 0x0003;
1203	uvesafb_exec(task);
1204
1205	/*
1206	* Now try to restore whatever hardware state we might have
1207	* saved when the fb device was first opened.
1208	*/
1209	uvesafb_vbe_state_restore(par, state_buf: par->vbe_state_orig);
1210	out:
1211	atomic_dec(v: &par->ref_count);
1212	uvesafb_free(task);
1213	return 0;
1214	}
1215
1216	static int uvesafb_set_par(struct fb_info *info)
1217	{
1218	struct uvesafb_par *par = info->par;
1219	struct uvesafb_ktask *task = NULL;
1220	struct vbe_crtc_ib *crtc = NULL;
1221	struct vbe_mode_ib *mode = NULL;
1222	int i, err = 0, depth = info->var.bits_per_pixel;
1223
1224	if (depth > 8 && depth != 32)
1225	depth = info->var.red.length + info->var.green.length +
1226	info->var.blue.length;
1227
1228	i = uvesafb_vbe_find_mode(par, xres: info->var.xres, yres: info->var.yres, depth,
1229	UVESAFB_EXACT_RES | UVESAFB_EXACT_DEPTH);
1230	if (i >= 0)
1231	mode = &par->vbe_modes[i];
1232	else
1233	return -EINVAL;
1234
1235	task = uvesafb_prep();
1236	if (!task)
1237	return -ENOMEM;
1238	setmode:
1239	task->t.regs.eax = 0x4f02;
1240	task->t.regs.ebx = mode->mode_id | 0x4000; /* use LFB */
1241
1242	if (par->vbe_ib.vbe_version >= 0x0300 && !par->nocrtc &&
1243	info->var.pixclock != 0) {
1244	task->t.regs.ebx |= 0x0800; /* use CRTC data */
1245	task->t.flags = TF_BUF_ESDI;
1246	crtc = kzalloc(size: sizeof(struct vbe_crtc_ib), GFP_KERNEL);
1247	if (!crtc) {
1248	err = -ENOMEM;
1249	goto out;
1250	}
1251	crtc->horiz_start = info->var.xres + info->var.right_margin;
1252	crtc->horiz_end = crtc->horiz_start + info->var.hsync_len;
1253	crtc->horiz_total = crtc->horiz_end + info->var.left_margin;
1254
1255	crtc->vert_start = info->var.yres + info->var.lower_margin;
1256	crtc->vert_end = crtc->vert_start + info->var.vsync_len;
1257	crtc->vert_total = crtc->vert_end + info->var.upper_margin;
1258
1259	crtc->pixel_clock = PICOS2KHZ(info->var.pixclock) * 1000;
1260	crtc->refresh_rate = (u16)(100 * (crtc->pixel_clock /
1261	(crtc->vert_total * crtc->horiz_total)));
1262
1263	if (info->var.vmode & FB_VMODE_DOUBLE)
1264	crtc->flags |= 0x1;
1265	if (info->var.vmode & FB_VMODE_INTERLACED)
1266	crtc->flags |= 0x2;
1267	if (!(info->var.sync & FB_SYNC_HOR_HIGH_ACT))
1268	crtc->flags |= 0x4;
1269	if (!(info->var.sync & FB_SYNC_VERT_HIGH_ACT))
1270	crtc->flags |= 0x8;
1271	memcpy(&par->crtc, crtc, sizeof(*crtc));
1272	} else {
1273	memset(&par->crtc, 0, sizeof(*crtc));
1274	}
1275
1276	task->t.buf_len = sizeof(struct vbe_crtc_ib);
1277	task->buf = &par->crtc;
1278
1279	err = uvesafb_exec(task);
1280	if (err || (task->t.regs.eax & 0xffff) != 0x004f) {
1281	/*
1282	* The mode switch might have failed because we tried to
1283	* use our own timings. Try again with the default timings.
1284	*/
1285	if (crtc != NULL) {
1286	pr_warn("mode switch failed (eax=0x%x, err=%d) - trying again with default timings\n",
1287	task->t.regs.eax, err);
1288	uvesafb_reset(task);
1289	kfree(objp: crtc);
1290	crtc = NULL;
1291	info->var.pixclock = 0;
1292	goto setmode;
1293	} else {
1294	pr_err("mode switch failed (eax=0x%x, err=%d)\n",
1295	task->t.regs.eax, err);
1296	err = -EINVAL;
1297	goto out;
1298	}
1299	}
1300	par->mode_idx = i;
1301
1302	/* For 8bpp modes, always try to set the DAC to 8 bits. */
1303	if (par->vbe_ib.capabilities & VBE_CAP_CAN_SWITCH_DAC &&
1304	mode->bits_per_pixel <= 8) {
1305	uvesafb_reset(task);
1306	task->t.regs.eax = 0x4f08;
1307	task->t.regs.ebx = 0x0800;
1308
1309	err = uvesafb_exec(task);
1310	if (err || (task->t.regs.eax & 0xffff) != 0x004f ||
1311	((task->t.regs.ebx & 0xff00) >> 8) != 8) {
1312	dac_width = 6;
1313	} else {
1314	dac_width = 8;
1315	}
1316	}
1317
1318	info->fix.visual = (info->var.bits_per_pixel == 8) ?
1319	FB_VISUAL_PSEUDOCOLOR : FB_VISUAL_TRUECOLOR;
1320	info->fix.line_length = mode->bytes_per_scan_line;
1321
1322	out:
1323	kfree(objp: crtc);
1324	uvesafb_free(task);
1325
1326	return err;
1327	}
1328
1329	static void uvesafb_check_limits(struct fb_var_screeninfo *var,
1330	struct fb_info *info)
1331	{
1332	const struct fb_videomode *mode;
1333	struct uvesafb_par *par = info->par;
1334
1335	/*
1336	* If pixclock is set to 0, then we're using default BIOS timings
1337	* and thus don't have to perform any checks here.
1338	*/
1339	if (!var->pixclock)
1340	return;
1341
1342	if (par->vbe_ib.vbe_version < 0x0300) {
1343	fb_get_mode(FB_VSYNCTIMINGS | FB_IGNOREMON, val: 60, var, info);
1344	return;
1345	}
1346
1347	if (!fb_validate_mode(var, info))
1348	return;
1349
1350	mode = fb_find_best_mode(var, head: &info->modelist);
1351	if (mode) {
1352	if (mode->xres == var->xres && mode->yres == var->yres &&
1353	!(mode->vmode & (FB_VMODE_INTERLACED | FB_VMODE_DOUBLE))) {
1354	fb_videomode_to_var(var, mode);
1355	return;
1356	}
1357	}
1358
1359	if (info->monspecs.gtf && !fb_get_mode(FB_MAXTIMINGS, val: 0, var, info))
1360	return;
1361	/* Use default refresh rate */
1362	var->pixclock = 0;
1363	}
1364
1365	static int uvesafb_check_var(struct fb_var_screeninfo *var,
1366	struct fb_info *info)
1367	{
1368	struct uvesafb_par *par = info->par;
1369	struct vbe_mode_ib *mode = NULL;
1370	int match = -1;
1371	int depth = var->red.length + var->green.length + var->blue.length;
1372
1373	/*
1374	* Various apps will use bits_per_pixel to set the color depth,
1375	* which is theoretically incorrect, but which we'll try to handle
1376	* here.
1377	*/
1378	if (depth == 0 || abs(depth - var->bits_per_pixel) >= 8)
1379	depth = var->bits_per_pixel;
1380
1381	match = uvesafb_vbe_find_mode(par, xres: var->xres, yres: var->yres, depth,
1382	UVESAFB_EXACT_RES);
1383	if (match == -1)
1384	return -EINVAL;
1385
1386	mode = &par->vbe_modes[match];
1387	uvesafb_setup_var(var, info, mode);
1388
1389	/*
1390	* Check whether we have remapped enough memory for this mode.
1391	* We might be called at an early stage, when we haven't remapped
1392	* any memory yet, in which case we simply skip the check.
1393	*/
1394	if (var->yres * mode->bytes_per_scan_line > info->fix.smem_len
1395	&& info->fix.smem_len)
1396	return -EINVAL;
1397
1398	if ((var->vmode & FB_VMODE_DOUBLE) &&
1399	!(par->vbe_modes[match].mode_attr & 0x100))
1400	var->vmode &= ~FB_VMODE_DOUBLE;
1401
1402	if ((var->vmode & FB_VMODE_INTERLACED) &&
1403	!(par->vbe_modes[match].mode_attr & 0x200))
1404	var->vmode &= ~FB_VMODE_INTERLACED;
1405
1406	uvesafb_check_limits(var, info);
1407
1408	var->xres_virtual = var->xres;
1409	var->yres_virtual = (par->ypan) ?
1410	info->fix.smem_len / mode->bytes_per_scan_line :
1411	var->yres;
1412	return 0;
1413	}
1414
1415	static struct fb_ops uvesafb_ops = {
1416	.owner = THIS_MODULE,
1417	.fb_open = uvesafb_open,
1418	.fb_release = uvesafb_release,
1419	FB_DEFAULT_IOMEM_OPS,
1420	.fb_setcolreg = uvesafb_setcolreg,
1421	.fb_setcmap = uvesafb_setcmap,
1422	.fb_pan_display = uvesafb_pan_display,
1423	.fb_blank = uvesafb_blank,
1424	.fb_check_var = uvesafb_check_var,
1425	.fb_set_par = uvesafb_set_par,
1426	};
1427
1428	static void uvesafb_init_info(struct fb_info *info, struct vbe_mode_ib *mode)
1429	{
1430	unsigned int size_vmode;
1431	unsigned int size_remap;
1432	unsigned int size_total;
1433	struct uvesafb_par *par = info->par;
1434	int i, h;
1435
1436	info->pseudo_palette = ((u8 *)info->par + sizeof(struct uvesafb_par));
1437	info->fix = uvesafb_fix;
1438	info->fix.ypanstep = par->ypan ? 1 : 0;
1439	info->fix.ywrapstep = (par->ypan > 1) ? 1 : 0;
1440
1441	/* Disable blanking if the user requested so. */
1442	if (!blank)
1443	uvesafb_ops.fb_blank = NULL;
1444
1445	/*
1446	* Find out how much IO memory is required for the mode with
1447	* the highest resolution.
1448	*/
1449	size_remap = 0;
1450	for (i = 0; i < par->vbe_modes_cnt; i++) {
1451	h = par->vbe_modes[i].bytes_per_scan_line *
1452	par->vbe_modes[i].y_res;
1453	if (h > size_remap)
1454	size_remap = h;
1455	}
1456	size_remap *= 2;
1457
1458	/*
1459	* size_vmode -- that is the amount of memory needed for the
1460	* used video mode, i.e. the minimum amount of
1461	* memory we need.
1462	*/
1463	size_vmode = info->var.yres * mode->bytes_per_scan_line;
1464
1465	/*
1466	* size_total -- all video memory we have. Used for mtrr
1467	* entries, resource allocation and bounds
1468	* checking.
1469	*/
1470	size_total = par->vbe_ib.total_memory * 65536;
1471	if (vram_total)
1472	size_total = vram_total * 1024 * 1024;
1473	if (size_total < size_vmode)
1474	size_total = size_vmode;
1475
1476	/*
1477	* size_remap -- the amount of video memory we are going to
1478	* use for vesafb. With modern cards it is no
1479	* option to simply use size_total as th
1480	* wastes plenty of kernel address space.
1481	*/
1482	if (vram_remap)
1483	size_remap = vram_remap * 1024 * 1024;
1484	if (size_remap < size_vmode)
1485	size_remap = size_vmode;
1486	if (size_remap > size_total)
1487	size_remap = size_total;
1488
1489	info->fix.smem_len = size_remap;
1490	info->fix.smem_start = mode->phys_base_ptr;
1491
1492	/*
1493	* We have to set yres_virtual here because when setup_var() was
1494	* called, smem_len wasn't defined yet.
1495	*/
1496	info->var.yres_virtual = info->fix.smem_len /
1497	mode->bytes_per_scan_line;
1498
1499	if (par->ypan && info->var.yres_virtual > info->var.yres) {
1500	pr_info("scrolling: %s using protected mode interface, yres_virtual=%d\n",
1501	(par->ypan > 1) ? "ywrap" : "ypan",
1502	info->var.yres_virtual);
1503	} else {
1504	pr_info("scrolling: redraw\n");
1505	info->var.yres_virtual = info->var.yres;
1506	par->ypan = 0;
1507	}
1508
1509	info->flags = (par->ypan ? FBINFO_HWACCEL_YPAN : 0);
1510
1511	if (!par->ypan)
1512	uvesafb_ops.fb_pan_display = NULL;
1513	}
1514
1515	static void uvesafb_init_mtrr(struct fb_info *info)
1516	{
1517	struct uvesafb_par *par = info->par;
1518
1519	if (mtrr && !(info->fix.smem_start & (PAGE_SIZE - 1))) {
1520	int temp_size = info->fix.smem_len;
1521
1522	int rc;
1523
1524	/* Find the largest power-of-two */
1525	temp_size = roundup_pow_of_two(temp_size);
1526
1527	/* Try and find a power of two to add */
1528	do {
1529	rc = arch_phys_wc_add(base: info->fix.smem_start, size: temp_size);
1530	temp_size >>= 1;
1531	} while (temp_size >= PAGE_SIZE && rc == -EINVAL);
1532
1533	if (rc >= 0)
1534	par->mtrr_handle = rc;
1535	}
1536	}
1537
1538	static void uvesafb_ioremap(struct fb_info *info)
1539	{
1540	info->screen_base = ioremap_wc(offset: info->fix.smem_start, size: info->fix.smem_len);
1541	}
1542
1543	static ssize_t uvesafb_show_vbe_ver(struct device *dev,
1544	struct device_attribute *attr, char *buf)
1545	{
1546	struct fb_info *info = dev_get_drvdata(dev);
1547	struct uvesafb_par *par = info->par;
1548
1549	return snprintf(buf, PAGE_SIZE, fmt: "%.4x\n", par->vbe_ib.vbe_version);
1550	}
1551
1552	static DEVICE_ATTR(vbe_version, S_IRUGO, uvesafb_show_vbe_ver, NULL);
1553
1554	static ssize_t uvesafb_show_vbe_modes(struct device *dev,
1555	struct device_attribute *attr, char *buf)
1556	{
1557	struct fb_info *info = dev_get_drvdata(dev);
1558	struct uvesafb_par *par = info->par;
1559	int ret = 0, i;
1560
1561	for (i = 0; i < par->vbe_modes_cnt && ret < PAGE_SIZE; i++) {
1562	ret += scnprintf(buf: buf + ret, PAGE_SIZE - ret,
1563	fmt: "%dx%d-%d, 0x%.4x\n",
1564	par->vbe_modes[i].x_res, par->vbe_modes[i].y_res,
1565	par->vbe_modes[i].depth, par->vbe_modes[i].mode_id);
1566	}
1567
1568	return ret;
1569	}
1570
1571	static DEVICE_ATTR(vbe_modes, S_IRUGO, uvesafb_show_vbe_modes, NULL);
1572
1573	static ssize_t uvesafb_show_vendor(struct device *dev,
1574	struct device_attribute *attr, char *buf)
1575	{
1576	struct fb_info *info = dev_get_drvdata(dev);
1577	struct uvesafb_par *par = info->par;
1578
1579	if (par->vbe_ib.oem_vendor_name_ptr)
1580	return sysfs_emit(buf, fmt: "%s\n", (char *)
1581	(&par->vbe_ib) + par->vbe_ib.oem_vendor_name_ptr);
1582	else
1583	return 0;
1584	}
1585
1586	static DEVICE_ATTR(oem_vendor, S_IRUGO, uvesafb_show_vendor, NULL);
1587
1588	static ssize_t uvesafb_show_product_name(struct device *dev,
1589	struct device_attribute *attr, char *buf)
1590	{
1591	struct fb_info *info = dev_get_drvdata(dev);
1592	struct uvesafb_par *par = info->par;
1593
1594	if (par->vbe_ib.oem_product_name_ptr)
1595	return sysfs_emit(buf, fmt: "%s\n", (char *)
1596	(&par->vbe_ib) + par->vbe_ib.oem_product_name_ptr);
1597	else
1598	return 0;
1599	}
1600
1601	static DEVICE_ATTR(oem_product_name, S_IRUGO, uvesafb_show_product_name, NULL);
1602
1603	static ssize_t uvesafb_show_product_rev(struct device *dev,
1604	struct device_attribute *attr, char *buf)
1605	{
1606	struct fb_info *info = dev_get_drvdata(dev);
1607	struct uvesafb_par *par = info->par;
1608
1609	if (par->vbe_ib.oem_product_rev_ptr)
1610	return sysfs_emit(buf, fmt: "%s\n", (char *)
1611	(&par->vbe_ib) + par->vbe_ib.oem_product_rev_ptr);
1612	else
1613	return 0;
1614	}
1615
1616	static DEVICE_ATTR(oem_product_rev, S_IRUGO, uvesafb_show_product_rev, NULL);
1617
1618	static ssize_t uvesafb_show_oem_string(struct device *dev,
1619	struct device_attribute *attr, char *buf)
1620	{
1621	struct fb_info *info = dev_get_drvdata(dev);
1622	struct uvesafb_par *par = info->par;
1623
1624	if (par->vbe_ib.oem_string_ptr)
1625	return sysfs_emit(buf, fmt: "%s\n",
1626	(char *)(&par->vbe_ib) + par->vbe_ib.oem_string_ptr);
1627	else
1628	return 0;
1629	}
1630
1631	static DEVICE_ATTR(oem_string, S_IRUGO, uvesafb_show_oem_string, NULL);
1632
1633	static ssize_t uvesafb_show_nocrtc(struct device *dev,
1634	struct device_attribute *attr, char *buf)
1635	{
1636	struct fb_info *info = dev_get_drvdata(dev);
1637	struct uvesafb_par *par = info->par;
1638
1639	return sysfs_emit(buf, fmt: "%d\n", par->nocrtc);
1640	}
1641
1642	static ssize_t uvesafb_store_nocrtc(struct device *dev,
1643	struct device_attribute *attr, const char *buf, size_t count)
1644	{
1645	struct fb_info *info = dev_get_drvdata(dev);
1646	struct uvesafb_par *par = info->par;
1647
1648	if (count > 0) {
1649	if (buf[0] == '0')
1650	par->nocrtc = 0;
1651	else
1652	par->nocrtc = 1;
1653	}
1654	return count;
1655	}
1656
1657	static DEVICE_ATTR(nocrtc, S_IRUGO | S_IWUSR, uvesafb_show_nocrtc,
1658	uvesafb_store_nocrtc);
1659
1660	static struct attribute *uvesafb_dev_attrs[] = {
1661	&dev_attr_vbe_version.attr,
1662	&dev_attr_vbe_modes.attr,
1663	&dev_attr_oem_vendor.attr,
1664	&dev_attr_oem_product_name.attr,
1665	&dev_attr_oem_product_rev.attr,
1666	&dev_attr_oem_string.attr,
1667	&dev_attr_nocrtc.attr,
1668	NULL,
1669	};
1670
1671	static const struct attribute_group uvesafb_dev_attgrp = {
1672	.name = NULL,
1673	.attrs = uvesafb_dev_attrs,
1674	};
1675
1676	static int uvesafb_probe(struct platform_device *dev)
1677	{
1678	struct fb_info *info;
1679	struct vbe_mode_ib *mode = NULL;
1680	struct uvesafb_par *par;
1681	int err = 0, i;
1682
1683	info = framebuffer_alloc(size: sizeof(*par) + sizeof(u32) * 256, dev: &dev->dev);
1684	if (!info)
1685	return -ENOMEM;
1686
1687	par = info->par;
1688
1689	err = uvesafb_vbe_init(info);
1690	if (err) {
1691	pr_err("vbe_init() failed with %d\n", err);
1692	goto out;
1693	}
1694
1695	info->fbops = &uvesafb_ops;
1696
1697	i = uvesafb_vbe_init_mode(info);
1698	if (i < 0) {
1699	err = -EINVAL;
1700	goto out;
1701	} else {
1702	mode = &par->vbe_modes[i];
1703	}
1704
1705	if (fb_alloc_cmap(cmap: &info->cmap, len: 256, transp: 0) < 0) {
1706	err = -ENXIO;
1707	goto out;
1708	}
1709
1710	uvesafb_init_info(info, mode);
1711
1712	if (!request_region(0x3c0, 32, "uvesafb")) {
1713	pr_err("request region 0x3c0-0x3e0 failed\n");
1714	err = -EIO;
1715	goto out_mode;
1716	}
1717
1718	if (!request_mem_region(info->fix.smem_start, info->fix.smem_len,
1719	"uvesafb")) {
1720	pr_err("cannot reserve video memory at 0x%lx\n",
1721	info->fix.smem_start);
1722	err = -EIO;
1723	goto out_reg;
1724	}
1725
1726	uvesafb_init_mtrr(info);
1727	uvesafb_ioremap(info);
1728
1729	if (!info->screen_base) {
1730	pr_err("abort, cannot ioremap 0x%x bytes of video memory at 0x%lx\n",
1731	info->fix.smem_len, info->fix.smem_start);
1732	err = -EIO;
1733	goto out_mem;
1734	}
1735
1736	platform_set_drvdata(pdev: dev, data: info);
1737
1738	if (register_framebuffer(fb_info: info) < 0) {
1739	pr_err("failed to register framebuffer device\n");
1740	err = -EINVAL;
1741	goto out_unmap;
1742	}
1743
1744	pr_info("framebuffer at 0x%lx, mapped to 0x%p, using %dk, total %dk\n",
1745	info->fix.smem_start, info->screen_base,
1746	info->fix.smem_len / 1024, par->vbe_ib.total_memory * 64);
1747	fb_info(info, "%s frame buffer device\n", info->fix.id);
1748
1749	err = sysfs_create_group(kobj: &dev->dev.kobj, grp: &uvesafb_dev_attgrp);
1750	if (err != 0)
1751	fb_warn(info, "failed to register attributes\n");
1752
1753	return 0;
1754
1755	out_unmap:
1756	iounmap(addr: info->screen_base);
1757	out_mem:
1758	arch_phys_wc_del(handle: par->mtrr_handle);
1759	release_mem_region(info->fix.smem_start, info->fix.smem_len);
1760	out_reg:
1761	release_region(0x3c0, 32);
1762	out_mode:
1763	if (!list_empty(head: &info->modelist))
1764	fb_destroy_modelist(head: &info->modelist);
1765	fb_destroy_modedb(modedb: info->monspecs.modedb);
1766	fb_dealloc_cmap(cmap: &info->cmap);
1767	out:
1768	kfree(objp: par->vbe_modes);
1769
1770	framebuffer_release(info);
1771	return err;
1772	}
1773
1774	static void uvesafb_remove(struct platform_device *dev)
1775	{
1776	struct fb_info *info = platform_get_drvdata(pdev: dev);
1777	struct uvesafb_par *par = info->par;
1778
1779	sysfs_remove_group(kobj: &dev->dev.kobj, grp: &uvesafb_dev_attgrp);
1780	unregister_framebuffer(fb_info: info);
1781	release_region(0x3c0, 32);
1782	iounmap(addr: info->screen_base);
1783	arch_phys_wc_del(handle: par->mtrr_handle);
1784	release_mem_region(info->fix.smem_start, info->fix.smem_len);
1785	fb_destroy_modedb(modedb: info->monspecs.modedb);
1786	fb_dealloc_cmap(cmap: &info->cmap);
1787
1788	kfree(objp: par->vbe_modes);
1789	kfree(objp: par->vbe_state_orig);
1790	kfree(objp: par->vbe_state_saved);
1791
1792	framebuffer_release(info);
1793	}
1794
1795	static struct platform_driver uvesafb_driver = {
1796	.probe = uvesafb_probe,
1797	.remove_new = uvesafb_remove,
1798	.driver = {
1799	.name = "uvesafb",
1800	},
1801	};
1802
1803	static struct platform_device *uvesafb_device;
1804
1805	#ifndef MODULE
1806	static int uvesafb_setup(char *options)
1807	{
1808	char *this_opt;
1809
1810	if (!options || !*options)
1811	return 0;
1812
1813	while ((this_opt = strsep(&options, ",")) != NULL) {
1814	if (!*this_opt) continue;
1815
1816	if (!strcmp(this_opt, "redraw"))
1817	ypan = 0;
1818	else if (!strcmp(this_opt, "ypan"))
1819	ypan = 1;
1820	else if (!strcmp(this_opt, "ywrap"))
1821	ypan = 2;
1822	else if (!strcmp(this_opt, "vgapal"))
1823	pmi_setpal = false;
1824	else if (!strcmp(this_opt, "pmipal"))
1825	pmi_setpal = true;
1826	else if (!strncmp(this_opt, "mtrr:", 5))
1827	mtrr = simple_strtoul(this_opt+5, NULL, 0);
1828	else if (!strcmp(this_opt, "nomtrr"))
1829	mtrr = 0;
1830	else if (!strcmp(this_opt, "nocrtc"))
1831	nocrtc = true;
1832	else if (!strcmp(this_opt, "noedid"))
1833	noedid = true;
1834	else if (!strcmp(this_opt, "noblank"))
1835	blank = false;
1836	else if (!strncmp(this_opt, "vtotal:", 7))
1837	vram_total = simple_strtoul(this_opt + 7, NULL, 0);
1838	else if (!strncmp(this_opt, "vremap:", 7))
1839	vram_remap = simple_strtoul(this_opt + 7, NULL, 0);
1840	else if (!strncmp(this_opt, "maxhf:", 6))
1841	maxhf = simple_strtoul(this_opt + 6, NULL, 0);
1842	else if (!strncmp(this_opt, "maxvf:", 6))
1843	maxvf = simple_strtoul(this_opt + 6, NULL, 0);
1844	else if (!strncmp(this_opt, "maxclk:", 7))
1845	maxclk = simple_strtoul(this_opt + 7, NULL, 0);
1846	else if (!strncmp(this_opt, "vbemode:", 8))
1847	vbemode = simple_strtoul(this_opt + 8, NULL, 0);
1848	else if (this_opt[0] >= '0' && this_opt[0] <= '9') {
1849	mode_option = this_opt;
1850	} else {
1851	pr_warn("unrecognized option %s\n", this_opt);
1852	}
1853	}
1854
1855	if (mtrr != 3 && mtrr != 0)
1856	pr_warn("uvesafb: mtrr should be set to 0 or 3; %d is unsupported", mtrr);
1857
1858	return 0;
1859	}
1860	#endif /* !MODULE */
1861
1862	static ssize_t v86d_show(struct device_driver *dev, char *buf)
1863	{
1864	return snprintf(buf, PAGE_SIZE, fmt: "%s\n", v86d_path);
1865	}
1866
1867	static ssize_t v86d_store(struct device_driver *dev, const char *buf,
1868	size_t count)
1869	{
1870	strncpy(p: v86d_path, q: buf, PATH_MAX - 1);
1871	return count;
1872	}
1873	static DRIVER_ATTR_RW(v86d);
1874
1875	static int uvesafb_init(void)
1876	{
1877	int err;
1878
1879	#ifndef MODULE
1880	char *option = NULL;
1881
1882	if (fb_get_options(name: "uvesafb", option: &option))
1883	return -ENODEV;
1884	uvesafb_setup(options: option);
1885	#endif
1886	err = cn_add_callback(id: &uvesafb_cn_id, name: "uvesafb", callback: uvesafb_cn_callback);
1887	if (err)
1888	return err;
1889
1890	err = platform_driver_register(&uvesafb_driver);
1891
1892	if (!err) {
1893	uvesafb_device = platform_device_alloc(name: "uvesafb", id: 0);
1894	if (uvesafb_device)
1895	err = platform_device_add(pdev: uvesafb_device);
1896	else
1897	err = -ENOMEM;
1898
1899	if (err) {
1900	platform_device_put(pdev: uvesafb_device);
1901	platform_driver_unregister(&uvesafb_driver);
1902	cn_del_callback(id: &uvesafb_cn_id);
1903	return err;
1904	}
1905
1906	err = driver_create_file(driver: &uvesafb_driver.driver,
1907	attr: &driver_attr_v86d);
1908	if (err) {
1909	pr_warn("failed to register attributes\n");
1910	err = 0;
1911	}
1912	}
1913	return err;
1914	}
1915
1916	module_init(uvesafb_init);
1917
1918	static void uvesafb_exit(void)
1919	{
1920	struct uvesafb_ktask *task;
1921
1922	if (v86d_started) {
1923	task = uvesafb_prep();
1924	if (task) {
1925	task->t.flags = TF_EXIT;
1926	uvesafb_exec(task);
1927	uvesafb_free(task);
1928	}
1929	}
1930
1931	driver_remove_file(driver: &uvesafb_driver.driver, attr: &driver_attr_v86d);
1932	platform_device_unregister(uvesafb_device);
1933	platform_driver_unregister(&uvesafb_driver);
1934	cn_del_callback(id: &uvesafb_cn_id);
1935	}
1936
1937	module_exit(uvesafb_exit);
1938
1939	static int param_set_scroll(const char *val, const struct kernel_param *kp)
1940	{
1941	ypan = 0;
1942
1943	if (!strcmp(val, "redraw"))
1944	ypan = 0;
1945	else if (!strcmp(val, "ypan"))
1946	ypan = 1;
1947	else if (!strcmp(val, "ywrap"))
1948	ypan = 2;
1949	else
1950	return -EINVAL;
1951
1952	return 0;
1953	}
1954	static const struct kernel_param_ops param_ops_scroll = {
1955	.set = param_set_scroll,
1956	};
1957	#define param_check_scroll(name, p) __param_check(name, p, void)
1958
1959	module_param_named(scroll, ypan, scroll, 0);
1960	MODULE_PARM_DESC(scroll,
1961	"Scrolling mode, set to 'redraw', 'ypan', or 'ywrap'");
1962	module_param_named(vgapal, pmi_setpal, invbool, 0);
1963	MODULE_PARM_DESC(vgapal, "Set palette using VGA registers");
1964	module_param_named(pmipal, pmi_setpal, bool, 0);
1965	MODULE_PARM_DESC(pmipal, "Set palette using PMI calls");
1966	module_param(mtrr, uint, 0);
1967	MODULE_PARM_DESC(mtrr,
1968	"Memory Type Range Registers setting. Use 0 to disable.");
1969	module_param(blank, bool, 0);
1970	MODULE_PARM_DESC(blank, "Enable hardware blanking");
1971	module_param(nocrtc, bool, 0);
1972	MODULE_PARM_DESC(nocrtc, "Ignore CRTC timings when setting modes");
1973	module_param(noedid, bool, 0);
1974	MODULE_PARM_DESC(noedid,
1975	"Ignore EDID-provided monitor limits when setting modes");
1976	module_param(vram_remap, uint, 0);
1977	MODULE_PARM_DESC(vram_remap, "Set amount of video memory to be used [MiB]");
1978	module_param(vram_total, uint, 0);
1979	MODULE_PARM_DESC(vram_total, "Set total amount of video memory [MiB]");
1980	module_param(maxclk, ushort, 0);
1981	MODULE_PARM_DESC(maxclk, "Maximum pixelclock [MHz], overrides EDID data");
1982	module_param(maxhf, ushort, 0);
1983	MODULE_PARM_DESC(maxhf,
1984	"Maximum horizontal frequency [kHz], overrides EDID data");
1985	module_param(maxvf, ushort, 0);
1986	MODULE_PARM_DESC(maxvf,
1987	"Maximum vertical frequency [Hz], overrides EDID data");
1988	module_param(mode_option, charp, 0);
1989	MODULE_PARM_DESC(mode_option,
1990	"Specify initial video mode as \"<xres>x<yres>[-<bpp>][@<refresh>]\"");
1991	module_param(vbemode, ushort, 0);
1992	MODULE_PARM_DESC(vbemode,
1993	"VBE mode number to set, overrides the 'mode' option");
1994	module_param_string(v86d, v86d_path, PATH_MAX, 0660);
1995	MODULE_PARM_DESC(v86d, "Path to the v86d userspace helper.");
1996
1997	MODULE_LICENSE("GPL");
1998	MODULE_AUTHOR("Michal Januszewski <spock@gentoo.org>");
1999	MODULE_DESCRIPTION("Framebuffer driver for VBE2.0+ compliant graphics boards");
2000
2001