1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * Copyright (c) Intel Corp. 2007.
4  * All Rights Reserved.
5  *
6  * Intel funded Tungsten Graphics (http://www.tungstengraphics.com) to
7  * develop this driver.
8  *
9  * This file is part of the Vermilion Range fb driver.
10  *
11  * Authors:
12  *   Thomas Hellström <thomas-at-tungstengraphics-dot-com>
13  *   Michel Dänzer <michel-at-tungstengraphics-dot-com>
14  *   Alan Hourihane <alanh-at-tungstengraphics-dot-com>
15  */
16 
17 #include <linux/aperture.h>
18 #include <linux/module.h>
19 #include <linux/kernel.h>
20 #include <linux/errno.h>
21 #include <linux/string.h>
22 #include <linux/delay.h>
23 #include <linux/slab.h>
24 #include <linux/mm.h>
25 #include <linux/fb.h>
26 #include <linux/pci.h>
27 #include <asm/set_memory.h>
28 #include <asm/tlbflush.h>
29 #include <linux/mmzone.h>
30 
31 /* #define VERMILION_DEBUG */
32 
33 #include "vermilion.h"
34 
35 #define MODULE_NAME "vmlfb"
36 
37 #define VML_TOHW(_val, _width) ((((_val) << (_width)) + 0x7FFF - (_val)) >> 16)
38 
39 static struct mutex vml_mutex;
40 static struct list_head global_no_mode;
41 static struct list_head global_has_mode;
42 static struct fb_ops vmlfb_ops;
43 static struct vml_sys *subsys = NULL;
44 static char *vml_default_mode = "1024x768@60";
45 static const struct fb_videomode defaultmode = {
46 	NULL, 60, 1024, 768, 12896, 144, 24, 29, 3, 136, 6,
47 	0, FB_VMODE_NONINTERLACED
48 };
49 
50 static u32 vml_mem_requested = (10 * 1024 * 1024);
51 static u32 vml_mem_contig = (4 * 1024 * 1024);
52 static u32 vml_mem_min = (4 * 1024 * 1024);
53 
54 static u32 vml_clocks[] = {
55 	6750,
56 	13500,
57 	27000,
58 	29700,
59 	37125,
60 	54000,
61 	59400,
62 	74250,
63 	120000,
64 	148500
65 };
66 
67 static u32 vml_num_clocks = ARRAY_SIZE(vml_clocks);
68 
69 /*
70  * Allocate a contiguous vram area and make its linear kernel map
71  * uncached.
72  */
73 
74 static int vmlfb_alloc_vram_area(struct vram_area *va, unsigned max_order,
75 				 unsigned min_order)
76 {
77 	gfp_t flags;
78 	unsigned long i;
79 
80 	max_order++;
81 	do {
82 		/*
83 		 * Really try hard to get the needed memory.
84 		 * We need memory below the first 32MB, so we
85 		 * add the __GFP_DMA flag that guarantees that we are
86 		 * below the first 16MB.
87 		 */
88 
89 		flags = __GFP_DMA | __GFP_HIGH | __GFP_KSWAPD_RECLAIM;
90 		va->logical =
91 			 __get_free_pages(flags, --max_order);
92 	} while (va->logical == 0 && max_order > min_order);
93 
94 	if (!va->logical)
95 		return -ENOMEM;
96 
97 	va->phys = virt_to_phys((void *)va->logical);
98 	va->size = PAGE_SIZE << max_order;
99 	va->order = max_order;
100 
101 	/*
102 	 * It seems like __get_free_pages only ups the usage count
103 	 * of the first page. This doesn't work with fault mapping, so
104 	 * up the usage count once more (XXX: should use split_page or
105 	 * compound page).
106 	 */
107 
108 	memset((void *)va->logical, 0x00, va->size);
109 	for (i = va->logical; i < va->logical + va->size; i += PAGE_SIZE) {
110 		get_page(virt_to_page(i));
111 	}
112 
113 	/*
114 	 * Change caching policy of the linear kernel map to avoid
115 	 * mapping type conflicts with user-space mappings.
116 	 */
117 	set_pages_uc(virt_to_page(va->logical), va->size >> PAGE_SHIFT);
118 
119 	printk(KERN_DEBUG MODULE_NAME
120 	       ": Allocated %ld bytes vram area at 0x%08lx\n",
121 	       va->size, va->phys);
122 
123 	return 0;
124 }
125 
126 /*
127  * Free a contiguous vram area and reset its linear kernel map
128  * mapping type.
129  */
130 
131 static void vmlfb_free_vram_area(struct vram_area *va)
132 {
133 	unsigned long j;
134 
135 	if (va->logical) {
136 
137 		/*
138 		 * Reset the linear kernel map caching policy.
139 		 */
140 
141 		set_pages_wb(virt_to_page(va->logical),
142 				 va->size >> PAGE_SHIFT);
143 
144 		/*
145 		 * Decrease the usage count on the pages we've used
146 		 * to compensate for upping when allocating.
147 		 */
148 
149 		for (j = va->logical; j < va->logical + va->size;
150 		     j += PAGE_SIZE) {
151 			(void)put_page_testzero(virt_to_page(j));
152 		}
153 
154 		printk(KERN_DEBUG MODULE_NAME
155 		       ": Freeing %ld bytes vram area at 0x%08lx\n",
156 		       va->size, va->phys);
157 		free_pages(va->logical, va->order);
158 
159 		va->logical = 0;
160 	}
161 }
162 
163 /*
164  * Free allocated vram.
165  */
166 
167 static void vmlfb_free_vram(struct vml_info *vinfo)
168 {
169 	int i;
170 
171 	for (i = 0; i < vinfo->num_areas; ++i) {
172 		vmlfb_free_vram_area(&vinfo->vram[i]);
173 	}
174 	vinfo->num_areas = 0;
175 }
176 
177 /*
178  * Allocate vram. Currently we try to allocate contiguous areas from the
179  * __GFP_DMA zone and puzzle them together. A better approach would be to
180  * allocate one contiguous area for scanout and use one-page allocations for
181  * offscreen areas. This requires user-space and GPU virtual mappings.
182  */
183 
184 static int vmlfb_alloc_vram(struct vml_info *vinfo,
185 			    size_t requested,
186 			    size_t min_total, size_t min_contig)
187 {
188 	int i, j;
189 	int order;
190 	int contiguous;
191 	int err;
192 	struct vram_area *va;
193 	struct vram_area *va2;
194 
195 	vinfo->num_areas = 0;
196 	for (i = 0; i < VML_VRAM_AREAS; ++i) {
197 		va = &vinfo->vram[i];
198 		order = 0;
199 
200 		while (requested > (PAGE_SIZE << order) && order <= MAX_ORDER)
201 			order++;
202 
203 		err = vmlfb_alloc_vram_area(va, order, 0);
204 
205 		if (err)
206 			break;
207 
208 		if (i == 0) {
209 			vinfo->vram_start = va->phys;
210 			vinfo->vram_logical = (void __iomem *) va->logical;
211 			vinfo->vram_contig_size = va->size;
212 			vinfo->num_areas = 1;
213 		} else {
214 			contiguous = 0;
215 
216 			for (j = 0; j < i; ++j) {
217 				va2 = &vinfo->vram[j];
218 				if (va->phys + va->size == va2->phys ||
219 				    va2->phys + va2->size == va->phys) {
220 					contiguous = 1;
221 					break;
222 				}
223 			}
224 
225 			if (contiguous) {
226 				vinfo->num_areas++;
227 				if (va->phys < vinfo->vram_start) {
228 					vinfo->vram_start = va->phys;
229 					vinfo->vram_logical =
230 						(void __iomem *)va->logical;
231 				}
232 				vinfo->vram_contig_size += va->size;
233 			} else {
234 				vmlfb_free_vram_area(va);
235 				break;
236 			}
237 		}
238 
239 		if (requested < va->size)
240 			break;
241 		else
242 			requested -= va->size;
243 	}
244 
245 	if (vinfo->vram_contig_size > min_total &&
246 	    vinfo->vram_contig_size > min_contig) {
247 
248 		printk(KERN_DEBUG MODULE_NAME
249 		       ": Contiguous vram: %ld bytes at physical 0x%08lx.\n",
250 		       (unsigned long)vinfo->vram_contig_size,
251 		       (unsigned long)vinfo->vram_start);
252 
253 		return 0;
254 	}
255 
256 	printk(KERN_ERR MODULE_NAME
257 	       ": Could not allocate requested minimal amount of vram.\n");
258 
259 	vmlfb_free_vram(vinfo);
260 
261 	return -ENOMEM;
262 }
263 
264 /*
265  * Find the GPU to use with our display controller.
266  */
267 
268 static int vmlfb_get_gpu(struct vml_par *par)
269 {
270 	mutex_lock(&vml_mutex);
271 
272 	par->gpu = pci_get_device(PCI_VENDOR_ID_INTEL, VML_DEVICE_GPU, NULL);
273 
274 	if (!par->gpu) {
275 		mutex_unlock(&vml_mutex);
276 		return -ENODEV;
277 	}
278 
279 	mutex_unlock(&vml_mutex);
280 
281 	if (pci_enable_device(par->gpu) < 0) {
282 		pci_dev_put(par->gpu);
283 		return -ENODEV;
284 	}
285 
286 	return 0;
287 }
288 
289 /*
290  * Find a contiguous vram area that contains a given offset from vram start.
291  */
292 static int vmlfb_vram_offset(struct vml_info *vinfo, unsigned long offset)
293 {
294 	unsigned long aoffset;
295 	unsigned i;
296 
297 	for (i = 0; i < vinfo->num_areas; ++i) {
298 		aoffset = offset - (vinfo->vram[i].phys - vinfo->vram_start);
299 
300 		if (aoffset < vinfo->vram[i].size) {
301 			return 0;
302 		}
303 	}
304 
305 	return -EINVAL;
306 }
307 
308 /*
309  * Remap the MMIO register spaces of the VDC and the GPU.
310  */
311 
312 static int vmlfb_enable_mmio(struct vml_par *par)
313 {
314 	int err;
315 
316 	par->vdc_mem_base = pci_resource_start(par->vdc, 0);
317 	par->vdc_mem_size = pci_resource_len(par->vdc, 0);
318 	if (!request_mem_region(par->vdc_mem_base, par->vdc_mem_size, "vmlfb")) {
319 		printk(KERN_ERR MODULE_NAME
320 		       ": Could not claim display controller MMIO.\n");
321 		return -EBUSY;
322 	}
323 	par->vdc_mem = ioremap(par->vdc_mem_base, par->vdc_mem_size);
324 	if (par->vdc_mem == NULL) {
325 		printk(KERN_ERR MODULE_NAME
326 		       ": Could not map display controller MMIO.\n");
327 		err = -ENOMEM;
328 		goto out_err_0;
329 	}
330 
331 	par->gpu_mem_base = pci_resource_start(par->gpu, 0);
332 	par->gpu_mem_size = pci_resource_len(par->gpu, 0);
333 	if (!request_mem_region(par->gpu_mem_base, par->gpu_mem_size, "vmlfb")) {
334 		printk(KERN_ERR MODULE_NAME ": Could not claim GPU MMIO.\n");
335 		err = -EBUSY;
336 		goto out_err_1;
337 	}
338 	par->gpu_mem = ioremap(par->gpu_mem_base, par->gpu_mem_size);
339 	if (par->gpu_mem == NULL) {
340 		printk(KERN_ERR MODULE_NAME ": Could not map GPU MMIO.\n");
341 		err = -ENOMEM;
342 		goto out_err_2;
343 	}
344 
345 	return 0;
346 
347 out_err_2:
348 	release_mem_region(par->gpu_mem_base, par->gpu_mem_size);
349 out_err_1:
350 	iounmap(par->vdc_mem);
351 out_err_0:
352 	release_mem_region(par->vdc_mem_base, par->vdc_mem_size);
353 	return err;
354 }
355 
356 /*
357  * Unmap the VDC and GPU register spaces.
358  */
359 
360 static void vmlfb_disable_mmio(struct vml_par *par)
361 {
362 	iounmap(par->gpu_mem);
363 	release_mem_region(par->gpu_mem_base, par->gpu_mem_size);
364 	iounmap(par->vdc_mem);
365 	release_mem_region(par->vdc_mem_base, par->vdc_mem_size);
366 }
367 
368 /*
369  * Release and uninit the VDC and GPU.
370  */
371 
372 static void vmlfb_release_devices(struct vml_par *par)
373 {
374 	if (atomic_dec_and_test(&par->refcount)) {
375 		pci_disable_device(par->gpu);
376 		pci_disable_device(par->vdc);
377 	}
378 }
379 
380 /*
381  * Free up allocated resources for a device.
382  */
383 
384 static void vml_pci_remove(struct pci_dev *dev)
385 {
386 	struct fb_info *info;
387 	struct vml_info *vinfo;
388 	struct vml_par *par;
389 
390 	info = pci_get_drvdata(dev);
391 	if (info) {
392 		vinfo = container_of(info, struct vml_info, info);
393 		par = vinfo->par;
394 		mutex_lock(&vml_mutex);
395 		unregister_framebuffer(info);
396 		fb_dealloc_cmap(&info->cmap);
397 		vmlfb_free_vram(vinfo);
398 		vmlfb_disable_mmio(par);
399 		vmlfb_release_devices(par);
400 		kfree(vinfo);
401 		kfree(par);
402 		mutex_unlock(&vml_mutex);
403 	}
404 }
405 
406 static void vmlfb_set_pref_pixel_format(struct fb_var_screeninfo *var)
407 {
408 	switch (var->bits_per_pixel) {
409 	case 16:
410 		var->blue.offset = 0;
411 		var->blue.length = 5;
412 		var->green.offset = 5;
413 		var->green.length = 5;
414 		var->red.offset = 10;
415 		var->red.length = 5;
416 		var->transp.offset = 15;
417 		var->transp.length = 1;
418 		break;
419 	case 32:
420 		var->blue.offset = 0;
421 		var->blue.length = 8;
422 		var->green.offset = 8;
423 		var->green.length = 8;
424 		var->red.offset = 16;
425 		var->red.length = 8;
426 		var->transp.offset = 24;
427 		var->transp.length = 0;
428 		break;
429 	default:
430 		break;
431 	}
432 
433 	var->blue.msb_right = var->green.msb_right =
434 	    var->red.msb_right = var->transp.msb_right = 0;
435 }
436 
437 /*
438  * Device initialization.
439  * We initialize one vml_par struct per device and one vml_info
440  * struct per pipe. Currently we have only one pipe.
441  */
442 
443 static int vml_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
444 {
445 	struct vml_info *vinfo;
446 	struct fb_info *info;
447 	struct vml_par *par;
448 	int err;
449 
450 	err = aperture_remove_conflicting_pci_devices(dev, "vmlfb");
451 	if (err)
452 		return err;
453 
454 	par = kzalloc(sizeof(*par), GFP_KERNEL);
455 	if (par == NULL)
456 		return -ENOMEM;
457 
458 	vinfo = kzalloc(sizeof(*vinfo), GFP_KERNEL);
459 	if (vinfo == NULL) {
460 		err = -ENOMEM;
461 		goto out_err_0;
462 	}
463 
464 	vinfo->par = par;
465 	par->vdc = dev;
466 	atomic_set(&par->refcount, 1);
467 
468 	switch (id->device) {
469 	case VML_DEVICE_VDC:
470 		if ((err = vmlfb_get_gpu(par)))
471 			goto out_err_1;
472 		pci_set_drvdata(dev, &vinfo->info);
473 		break;
474 	default:
475 		err = -ENODEV;
476 		goto out_err_1;
477 	}
478 
479 	info = &vinfo->info;
480 	info->flags = FBINFO_DEFAULT | FBINFO_PARTIAL_PAN_OK;
481 
482 	err = vmlfb_enable_mmio(par);
483 	if (err)
484 		goto out_err_2;
485 
486 	err = vmlfb_alloc_vram(vinfo, vml_mem_requested,
487 			       vml_mem_contig, vml_mem_min);
488 	if (err)
489 		goto out_err_3;
490 
491 	strcpy(info->fix.id, "Vermilion Range");
492 	info->fix.mmio_start = 0;
493 	info->fix.mmio_len = 0;
494 	info->fix.smem_start = vinfo->vram_start;
495 	info->fix.smem_len = vinfo->vram_contig_size;
496 	info->fix.type = FB_TYPE_PACKED_PIXELS;
497 	info->fix.visual = FB_VISUAL_TRUECOLOR;
498 	info->fix.ypanstep = 1;
499 	info->fix.xpanstep = 1;
500 	info->fix.ywrapstep = 0;
501 	info->fix.accel = FB_ACCEL_NONE;
502 	info->screen_base = vinfo->vram_logical;
503 	info->pseudo_palette = vinfo->pseudo_palette;
504 	info->par = par;
505 	info->fbops = &vmlfb_ops;
506 	info->device = &dev->dev;
507 
508 	INIT_LIST_HEAD(&vinfo->head);
509 	vinfo->pipe_disabled = 1;
510 	vinfo->cur_blank_mode = FB_BLANK_UNBLANK;
511 
512 	info->var.grayscale = 0;
513 	info->var.bits_per_pixel = 16;
514 	vmlfb_set_pref_pixel_format(&info->var);
515 
516 	if (!fb_find_mode
517 	    (&info->var, info, vml_default_mode, NULL, 0, &defaultmode, 16)) {
518 		printk(KERN_ERR MODULE_NAME ": Could not find initial mode\n");
519 	}
520 
521 	if (fb_alloc_cmap(&info->cmap, 256, 1) < 0) {
522 		err = -ENOMEM;
523 		goto out_err_4;
524 	}
525 
526 	err = register_framebuffer(info);
527 	if (err) {
528 		printk(KERN_ERR MODULE_NAME ": Register framebuffer error.\n");
529 		goto out_err_5;
530 	}
531 
532 	printk("Initialized vmlfb\n");
533 
534 	return 0;
535 
536 out_err_5:
537 	fb_dealloc_cmap(&info->cmap);
538 out_err_4:
539 	vmlfb_free_vram(vinfo);
540 out_err_3:
541 	vmlfb_disable_mmio(par);
542 out_err_2:
543 	vmlfb_release_devices(par);
544 out_err_1:
545 	kfree(vinfo);
546 out_err_0:
547 	kfree(par);
548 	return err;
549 }
550 
551 static int vmlfb_open(struct fb_info *info, int user)
552 {
553 	/*
554 	 * Save registers here?
555 	 */
556 	return 0;
557 }
558 
559 static int vmlfb_release(struct fb_info *info, int user)
560 {
561 	/*
562 	 * Restore registers here.
563 	 */
564 
565 	return 0;
566 }
567 
568 static int vml_nearest_clock(int clock)
569 {
570 
571 	int i;
572 	int cur_index;
573 	int cur_diff;
574 	int diff;
575 
576 	cur_index = 0;
577 	cur_diff = clock - vml_clocks[0];
578 	cur_diff = (cur_diff < 0) ? -cur_diff : cur_diff;
579 	for (i = 1; i < vml_num_clocks; ++i) {
580 		diff = clock - vml_clocks[i];
581 		diff = (diff < 0) ? -diff : diff;
582 		if (diff < cur_diff) {
583 			cur_index = i;
584 			cur_diff = diff;
585 		}
586 	}
587 	return vml_clocks[cur_index];
588 }
589 
590 static int vmlfb_check_var_locked(struct fb_var_screeninfo *var,
591 				  struct vml_info *vinfo)
592 {
593 	u32 pitch;
594 	u64 mem;
595 	int nearest_clock;
596 	int clock;
597 	int clock_diff;
598 	struct fb_var_screeninfo v;
599 
600 	v = *var;
601 	clock = PICOS2KHZ(var->pixclock);
602 
603 	if (subsys && subsys->nearest_clock) {
604 		nearest_clock = subsys->nearest_clock(subsys, clock);
605 	} else {
606 		nearest_clock = vml_nearest_clock(clock);
607 	}
608 
609 	/*
610 	 * Accept a 20% diff.
611 	 */
612 
613 	clock_diff = nearest_clock - clock;
614 	clock_diff = (clock_diff < 0) ? -clock_diff : clock_diff;
615 	if (clock_diff > clock / 5) {
616 #if 0
617 		printk(KERN_DEBUG MODULE_NAME ": Diff failure. %d %d\n",clock_diff,clock);
618 #endif
619 		return -EINVAL;
620 	}
621 
622 	v.pixclock = KHZ2PICOS(nearest_clock);
623 
624 	if (var->xres > VML_MAX_XRES || var->yres > VML_MAX_YRES) {
625 		printk(KERN_DEBUG MODULE_NAME ": Resolution failure.\n");
626 		return -EINVAL;
627 	}
628 	if (var->xres_virtual > VML_MAX_XRES_VIRTUAL) {
629 		printk(KERN_DEBUG MODULE_NAME
630 		       ": Virtual resolution failure.\n");
631 		return -EINVAL;
632 	}
633 	switch (v.bits_per_pixel) {
634 	case 0 ... 16:
635 		v.bits_per_pixel = 16;
636 		break;
637 	case 17 ... 32:
638 		v.bits_per_pixel = 32;
639 		break;
640 	default:
641 		printk(KERN_DEBUG MODULE_NAME ": Invalid bpp: %d.\n",
642 		       var->bits_per_pixel);
643 		return -EINVAL;
644 	}
645 
646 	pitch = ALIGN((var->xres * var->bits_per_pixel) >> 3, 0x40);
647 	mem = (u64)pitch * var->yres_virtual;
648 	if (mem > vinfo->vram_contig_size) {
649 		return -ENOMEM;
650 	}
651 
652 	switch (v.bits_per_pixel) {
653 	case 16:
654 		if (var->blue.offset != 0 ||
655 		    var->blue.length != 5 ||
656 		    var->green.offset != 5 ||
657 		    var->green.length != 5 ||
658 		    var->red.offset != 10 ||
659 		    var->red.length != 5 ||
660 		    var->transp.offset != 15 || var->transp.length != 1) {
661 			vmlfb_set_pref_pixel_format(&v);
662 		}
663 		break;
664 	case 32:
665 		if (var->blue.offset != 0 ||
666 		    var->blue.length != 8 ||
667 		    var->green.offset != 8 ||
668 		    var->green.length != 8 ||
669 		    var->red.offset != 16 ||
670 		    var->red.length != 8 ||
671 		    (var->transp.length != 0 && var->transp.length != 8) ||
672 		    (var->transp.length == 8 && var->transp.offset != 24)) {
673 			vmlfb_set_pref_pixel_format(&v);
674 		}
675 		break;
676 	default:
677 		return -EINVAL;
678 	}
679 
680 	*var = v;
681 
682 	return 0;
683 }
684 
685 static int vmlfb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
686 {
687 	struct vml_info *vinfo = container_of(info, struct vml_info, info);
688 	int ret;
689 
690 	mutex_lock(&vml_mutex);
691 	ret = vmlfb_check_var_locked(var, vinfo);
692 	mutex_unlock(&vml_mutex);
693 
694 	return ret;
695 }
696 
697 static void vml_wait_vblank(struct vml_info *vinfo)
698 {
699 	/* Wait for vblank. For now, just wait for a 50Hz cycle (20ms)) */
700 	mdelay(20);
701 }
702 
703 static void vmlfb_disable_pipe(struct vml_info *vinfo)
704 {
705 	struct vml_par *par = vinfo->par;
706 
707 	/* Disable the MDVO pad */
708 	VML_WRITE32(par, VML_RCOMPSTAT, 0);
709 	while (!(VML_READ32(par, VML_RCOMPSTAT) & VML_MDVO_VDC_I_RCOMP)) ;
710 
711 	/* Disable display planes */
712 	VML_WRITE32(par, VML_DSPCCNTR,
713 		    VML_READ32(par, VML_DSPCCNTR) & ~VML_GFX_ENABLE);
714 	(void)VML_READ32(par, VML_DSPCCNTR);
715 	/* Wait for vblank for the disable to take effect */
716 	vml_wait_vblank(vinfo);
717 
718 	/* Next, disable display pipes */
719 	VML_WRITE32(par, VML_PIPEACONF, 0);
720 	(void)VML_READ32(par, VML_PIPEACONF);
721 
722 	vinfo->pipe_disabled = 1;
723 }
724 
725 #ifdef VERMILION_DEBUG
726 static void vml_dump_regs(struct vml_info *vinfo)
727 {
728 	struct vml_par *par = vinfo->par;
729 
730 	printk(KERN_DEBUG MODULE_NAME ": Modesetting register dump:\n");
731 	printk(KERN_DEBUG MODULE_NAME ": \tHTOTAL_A         : 0x%08x\n",
732 	       (unsigned)VML_READ32(par, VML_HTOTAL_A));
733 	printk(KERN_DEBUG MODULE_NAME ": \tHBLANK_A         : 0x%08x\n",
734 	       (unsigned)VML_READ32(par, VML_HBLANK_A));
735 	printk(KERN_DEBUG MODULE_NAME ": \tHSYNC_A          : 0x%08x\n",
736 	       (unsigned)VML_READ32(par, VML_HSYNC_A));
737 	printk(KERN_DEBUG MODULE_NAME ": \tVTOTAL_A         : 0x%08x\n",
738 	       (unsigned)VML_READ32(par, VML_VTOTAL_A));
739 	printk(KERN_DEBUG MODULE_NAME ": \tVBLANK_A         : 0x%08x\n",
740 	       (unsigned)VML_READ32(par, VML_VBLANK_A));
741 	printk(KERN_DEBUG MODULE_NAME ": \tVSYNC_A          : 0x%08x\n",
742 	       (unsigned)VML_READ32(par, VML_VSYNC_A));
743 	printk(KERN_DEBUG MODULE_NAME ": \tDSPCSTRIDE       : 0x%08x\n",
744 	       (unsigned)VML_READ32(par, VML_DSPCSTRIDE));
745 	printk(KERN_DEBUG MODULE_NAME ": \tDSPCSIZE         : 0x%08x\n",
746 	       (unsigned)VML_READ32(par, VML_DSPCSIZE));
747 	printk(KERN_DEBUG MODULE_NAME ": \tDSPCPOS          : 0x%08x\n",
748 	       (unsigned)VML_READ32(par, VML_DSPCPOS));
749 	printk(KERN_DEBUG MODULE_NAME ": \tDSPARB           : 0x%08x\n",
750 	       (unsigned)VML_READ32(par, VML_DSPARB));
751 	printk(KERN_DEBUG MODULE_NAME ": \tDSPCADDR         : 0x%08x\n",
752 	       (unsigned)VML_READ32(par, VML_DSPCADDR));
753 	printk(KERN_DEBUG MODULE_NAME ": \tBCLRPAT_A        : 0x%08x\n",
754 	       (unsigned)VML_READ32(par, VML_BCLRPAT_A));
755 	printk(KERN_DEBUG MODULE_NAME ": \tCANVSCLR_A       : 0x%08x\n",
756 	       (unsigned)VML_READ32(par, VML_CANVSCLR_A));
757 	printk(KERN_DEBUG MODULE_NAME ": \tPIPEASRC         : 0x%08x\n",
758 	       (unsigned)VML_READ32(par, VML_PIPEASRC));
759 	printk(KERN_DEBUG MODULE_NAME ": \tPIPEACONF        : 0x%08x\n",
760 	       (unsigned)VML_READ32(par, VML_PIPEACONF));
761 	printk(KERN_DEBUG MODULE_NAME ": \tDSPCCNTR         : 0x%08x\n",
762 	       (unsigned)VML_READ32(par, VML_DSPCCNTR));
763 	printk(KERN_DEBUG MODULE_NAME ": \tRCOMPSTAT        : 0x%08x\n",
764 	       (unsigned)VML_READ32(par, VML_RCOMPSTAT));
765 	printk(KERN_DEBUG MODULE_NAME ": End of modesetting register dump.\n");
766 }
767 #endif
768 
769 static int vmlfb_set_par_locked(struct vml_info *vinfo)
770 {
771 	struct vml_par *par = vinfo->par;
772 	struct fb_info *info = &vinfo->info;
773 	struct fb_var_screeninfo *var = &info->var;
774 	u32 htotal, hactive, hblank_start, hblank_end, hsync_start, hsync_end;
775 	u32 vtotal, vactive, vblank_start, vblank_end, vsync_start, vsync_end;
776 	u32 dspcntr;
777 	int clock;
778 
779 	vinfo->bytes_per_pixel = var->bits_per_pixel >> 3;
780 	vinfo->stride = ALIGN(var->xres_virtual * vinfo->bytes_per_pixel, 0x40);
781 	info->fix.line_length = vinfo->stride;
782 
783 	if (!subsys)
784 		return 0;
785 
786 	htotal =
787 	    var->xres + var->right_margin + var->hsync_len + var->left_margin;
788 	hactive = var->xres;
789 	hblank_start = var->xres;
790 	hblank_end = htotal;
791 	hsync_start = hactive + var->right_margin;
792 	hsync_end = hsync_start + var->hsync_len;
793 
794 	vtotal =
795 	    var->yres + var->lower_margin + var->vsync_len + var->upper_margin;
796 	vactive = var->yres;
797 	vblank_start = var->yres;
798 	vblank_end = vtotal;
799 	vsync_start = vactive + var->lower_margin;
800 	vsync_end = vsync_start + var->vsync_len;
801 
802 	dspcntr = VML_GFX_ENABLE | VML_GFX_GAMMABYPASS;
803 	clock = PICOS2KHZ(var->pixclock);
804 
805 	if (subsys->nearest_clock) {
806 		clock = subsys->nearest_clock(subsys, clock);
807 	} else {
808 		clock = vml_nearest_clock(clock);
809 	}
810 	printk(KERN_DEBUG MODULE_NAME
811 	       ": Set mode Hfreq : %d kHz, Vfreq : %d Hz.\n", clock / htotal,
812 	       ((clock / htotal) * 1000) / vtotal);
813 
814 	switch (var->bits_per_pixel) {
815 	case 16:
816 		dspcntr |= VML_GFX_ARGB1555;
817 		break;
818 	case 32:
819 		if (var->transp.length == 8)
820 			dspcntr |= VML_GFX_ARGB8888 | VML_GFX_ALPHAMULT;
821 		else
822 			dspcntr |= VML_GFX_RGB0888;
823 		break;
824 	default:
825 		return -EINVAL;
826 	}
827 
828 	vmlfb_disable_pipe(vinfo);
829 	mb();
830 
831 	if (subsys->set_clock)
832 		subsys->set_clock(subsys, clock);
833 	else
834 		return -EINVAL;
835 
836 	VML_WRITE32(par, VML_HTOTAL_A, ((htotal - 1) << 16) | (hactive - 1));
837 	VML_WRITE32(par, VML_HBLANK_A,
838 		    ((hblank_end - 1) << 16) | (hblank_start - 1));
839 	VML_WRITE32(par, VML_HSYNC_A,
840 		    ((hsync_end - 1) << 16) | (hsync_start - 1));
841 	VML_WRITE32(par, VML_VTOTAL_A, ((vtotal - 1) << 16) | (vactive - 1));
842 	VML_WRITE32(par, VML_VBLANK_A,
843 		    ((vblank_end - 1) << 16) | (vblank_start - 1));
844 	VML_WRITE32(par, VML_VSYNC_A,
845 		    ((vsync_end - 1) << 16) | (vsync_start - 1));
846 	VML_WRITE32(par, VML_DSPCSTRIDE, vinfo->stride);
847 	VML_WRITE32(par, VML_DSPCSIZE,
848 		    ((var->yres - 1) << 16) | (var->xres - 1));
849 	VML_WRITE32(par, VML_DSPCPOS, 0x00000000);
850 	VML_WRITE32(par, VML_DSPARB, VML_FIFO_DEFAULT);
851 	VML_WRITE32(par, VML_BCLRPAT_A, 0x00000000);
852 	VML_WRITE32(par, VML_CANVSCLR_A, 0x00000000);
853 	VML_WRITE32(par, VML_PIPEASRC,
854 		    ((var->xres - 1) << 16) | (var->yres - 1));
855 
856 	wmb();
857 	VML_WRITE32(par, VML_PIPEACONF, VML_PIPE_ENABLE);
858 	wmb();
859 	VML_WRITE32(par, VML_DSPCCNTR, dspcntr);
860 	wmb();
861 	VML_WRITE32(par, VML_DSPCADDR, (u32) vinfo->vram_start +
862 		    var->yoffset * vinfo->stride +
863 		    var->xoffset * vinfo->bytes_per_pixel);
864 
865 	VML_WRITE32(par, VML_RCOMPSTAT, VML_MDVO_PAD_ENABLE);
866 
867 	while (!(VML_READ32(par, VML_RCOMPSTAT) &
868 		 (VML_MDVO_VDC_I_RCOMP | VML_MDVO_PAD_ENABLE))) ;
869 
870 	vinfo->pipe_disabled = 0;
871 #ifdef VERMILION_DEBUG
872 	vml_dump_regs(vinfo);
873 #endif
874 
875 	return 0;
876 }
877 
878 static int vmlfb_set_par(struct fb_info *info)
879 {
880 	struct vml_info *vinfo = container_of(info, struct vml_info, info);
881 	int ret;
882 
883 	mutex_lock(&vml_mutex);
884 	list_move(&vinfo->head, (subsys) ? &global_has_mode : &global_no_mode);
885 	ret = vmlfb_set_par_locked(vinfo);
886 
887 	mutex_unlock(&vml_mutex);
888 	return ret;
889 }
890 
891 static int vmlfb_blank_locked(struct vml_info *vinfo)
892 {
893 	struct vml_par *par = vinfo->par;
894 	u32 cur = VML_READ32(par, VML_PIPEACONF);
895 
896 	switch (vinfo->cur_blank_mode) {
897 	case FB_BLANK_UNBLANK:
898 		if (vinfo->pipe_disabled) {
899 			vmlfb_set_par_locked(vinfo);
900 		}
901 		VML_WRITE32(par, VML_PIPEACONF, cur & ~VML_PIPE_FORCE_BORDER);
902 		(void)VML_READ32(par, VML_PIPEACONF);
903 		break;
904 	case FB_BLANK_NORMAL:
905 		if (vinfo->pipe_disabled) {
906 			vmlfb_set_par_locked(vinfo);
907 		}
908 		VML_WRITE32(par, VML_PIPEACONF, cur | VML_PIPE_FORCE_BORDER);
909 		(void)VML_READ32(par, VML_PIPEACONF);
910 		break;
911 	case FB_BLANK_VSYNC_SUSPEND:
912 	case FB_BLANK_HSYNC_SUSPEND:
913 		if (!vinfo->pipe_disabled) {
914 			vmlfb_disable_pipe(vinfo);
915 		}
916 		break;
917 	case FB_BLANK_POWERDOWN:
918 		if (!vinfo->pipe_disabled) {
919 			vmlfb_disable_pipe(vinfo);
920 		}
921 		break;
922 	default:
923 		return -EINVAL;
924 	}
925 
926 	return 0;
927 }
928 
929 static int vmlfb_blank(int blank_mode, struct fb_info *info)
930 {
931 	struct vml_info *vinfo = container_of(info, struct vml_info, info);
932 	int ret;
933 
934 	mutex_lock(&vml_mutex);
935 	vinfo->cur_blank_mode = blank_mode;
936 	ret = vmlfb_blank_locked(vinfo);
937 	mutex_unlock(&vml_mutex);
938 	return ret;
939 }
940 
941 static int vmlfb_pan_display(struct fb_var_screeninfo *var,
942 			     struct fb_info *info)
943 {
944 	struct vml_info *vinfo = container_of(info, struct vml_info, info);
945 	struct vml_par *par = vinfo->par;
946 
947 	mutex_lock(&vml_mutex);
948 	VML_WRITE32(par, VML_DSPCADDR, (u32) vinfo->vram_start +
949 		    var->yoffset * vinfo->stride +
950 		    var->xoffset * vinfo->bytes_per_pixel);
951 	(void)VML_READ32(par, VML_DSPCADDR);
952 	mutex_unlock(&vml_mutex);
953 
954 	return 0;
955 }
956 
957 static int vmlfb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
958 			   u_int transp, struct fb_info *info)
959 {
960 	u32 v;
961 
962 	if (regno >= 16)
963 		return -EINVAL;
964 
965 	if (info->var.grayscale) {
966 		red = green = blue = (red * 77 + green * 151 + blue * 28) >> 8;
967 	}
968 
969 	if (info->fix.visual != FB_VISUAL_TRUECOLOR)
970 		return -EINVAL;
971 
972 	red = VML_TOHW(red, info->var.red.length);
973 	blue = VML_TOHW(blue, info->var.blue.length);
974 	green = VML_TOHW(green, info->var.green.length);
975 	transp = VML_TOHW(transp, info->var.transp.length);
976 
977 	v = (red << info->var.red.offset) |
978 	    (green << info->var.green.offset) |
979 	    (blue << info->var.blue.offset) |
980 	    (transp << info->var.transp.offset);
981 
982 	switch (info->var.bits_per_pixel) {
983 	case 16:
984 		((u32 *) info->pseudo_palette)[regno] = v;
985 		break;
986 	case 24:
987 	case 32:
988 		((u32 *) info->pseudo_palette)[regno] = v;
989 		break;
990 	}
991 	return 0;
992 }
993 
994 static int vmlfb_mmap(struct fb_info *info, struct vm_area_struct *vma)
995 {
996 	struct vml_info *vinfo = container_of(info, struct vml_info, info);
997 	unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
998 	int ret;
999 	unsigned long prot;
1000 
1001 	ret = vmlfb_vram_offset(vinfo, offset);
1002 	if (ret)
1003 		return -EINVAL;
1004 
1005 	prot = pgprot_val(vma->vm_page_prot) & ~_PAGE_CACHE_MASK;
1006 	pgprot_val(vma->vm_page_prot) =
1007 		prot | cachemode2protval(_PAGE_CACHE_MODE_UC_MINUS);
1008 
1009 	return vm_iomap_memory(vma, vinfo->vram_start,
1010 			vinfo->vram_contig_size);
1011 }
1012 
1013 static int vmlfb_sync(struct fb_info *info)
1014 {
1015 	return 0;
1016 }
1017 
1018 static int vmlfb_cursor(struct fb_info *info, struct fb_cursor *cursor)
1019 {
1020 	return -EINVAL;	/* just to force soft_cursor() call */
1021 }
1022 
1023 static struct fb_ops vmlfb_ops = {
1024 	.owner = THIS_MODULE,
1025 	.fb_open = vmlfb_open,
1026 	.fb_release = vmlfb_release,
1027 	.fb_check_var = vmlfb_check_var,
1028 	.fb_set_par = vmlfb_set_par,
1029 	.fb_blank = vmlfb_blank,
1030 	.fb_pan_display = vmlfb_pan_display,
1031 	.fb_fillrect = cfb_fillrect,
1032 	.fb_copyarea = cfb_copyarea,
1033 	.fb_imageblit = cfb_imageblit,
1034 	.fb_cursor = vmlfb_cursor,
1035 	.fb_sync = vmlfb_sync,
1036 	.fb_mmap = vmlfb_mmap,
1037 	.fb_setcolreg = vmlfb_setcolreg
1038 };
1039 
1040 static const struct pci_device_id vml_ids[] = {
1041 	{PCI_DEVICE(PCI_VENDOR_ID_INTEL, VML_DEVICE_VDC)},
1042 	{0}
1043 };
1044 
1045 static struct pci_driver vmlfb_pci_driver = {
1046 	.name = "vmlfb",
1047 	.id_table = vml_ids,
1048 	.probe = vml_pci_probe,
1049 	.remove = vml_pci_remove,
1050 };
1051 
1052 static void __exit vmlfb_cleanup(void)
1053 {
1054 	pci_unregister_driver(&vmlfb_pci_driver);
1055 }
1056 
1057 static int __init vmlfb_init(void)
1058 {
1059 
1060 #ifndef MODULE
1061 	char *option = NULL;
1062 #endif
1063 
1064 	if (fb_modesetting_disabled("vmlfb"))
1065 		return -ENODEV;
1066 
1067 #ifndef MODULE
1068 	if (fb_get_options(MODULE_NAME, &option))
1069 		return -ENODEV;
1070 #endif
1071 
1072 	printk(KERN_DEBUG MODULE_NAME ": initializing\n");
1073 	mutex_init(&vml_mutex);
1074 	INIT_LIST_HEAD(&global_no_mode);
1075 	INIT_LIST_HEAD(&global_has_mode);
1076 
1077 	return pci_register_driver(&vmlfb_pci_driver);
1078 }
1079 
1080 int vmlfb_register_subsys(struct vml_sys *sys)
1081 {
1082 	struct vml_info *entry;
1083 	struct list_head *list;
1084 	u32 save_activate;
1085 
1086 	mutex_lock(&vml_mutex);
1087 	if (subsys != NULL) {
1088 		subsys->restore(subsys);
1089 	}
1090 	subsys = sys;
1091 	subsys->save(subsys);
1092 
1093 	/*
1094 	 * We need to restart list traversal for each item, since we
1095 	 * release the list mutex in the loop.
1096 	 */
1097 
1098 	list = global_no_mode.next;
1099 	while (list != &global_no_mode) {
1100 		list_del_init(list);
1101 		entry = list_entry(list, struct vml_info, head);
1102 
1103 		/*
1104 		 * First, try the current mode which might not be
1105 		 * completely validated with respect to the pixel clock.
1106 		 */
1107 
1108 		if (!vmlfb_check_var_locked(&entry->info.var, entry)) {
1109 			vmlfb_set_par_locked(entry);
1110 			list_add_tail(list, &global_has_mode);
1111 		} else {
1112 
1113 			/*
1114 			 * Didn't work. Try to find another mode,
1115 			 * that matches this subsys.
1116 			 */
1117 
1118 			mutex_unlock(&vml_mutex);
1119 			save_activate = entry->info.var.activate;
1120 			entry->info.var.bits_per_pixel = 16;
1121 			vmlfb_set_pref_pixel_format(&entry->info.var);
1122 			if (fb_find_mode(&entry->info.var,
1123 					 &entry->info,
1124 					 vml_default_mode, NULL, 0, NULL, 16)) {
1125 				entry->info.var.activate |=
1126 				    FB_ACTIVATE_FORCE | FB_ACTIVATE_NOW;
1127 				fb_set_var(&entry->info, &entry->info.var);
1128 			} else {
1129 				printk(KERN_ERR MODULE_NAME
1130 				       ": Sorry. no mode found for this subsys.\n");
1131 			}
1132 			entry->info.var.activate = save_activate;
1133 			mutex_lock(&vml_mutex);
1134 		}
1135 		vmlfb_blank_locked(entry);
1136 		list = global_no_mode.next;
1137 	}
1138 	mutex_unlock(&vml_mutex);
1139 
1140 	printk(KERN_DEBUG MODULE_NAME ": Registered %s subsystem.\n",
1141 				subsys->name ? subsys->name : "unknown");
1142 	return 0;
1143 }
1144 
1145 EXPORT_SYMBOL_GPL(vmlfb_register_subsys);
1146 
1147 void vmlfb_unregister_subsys(struct vml_sys *sys)
1148 {
1149 	struct vml_info *entry, *next;
1150 
1151 	mutex_lock(&vml_mutex);
1152 	if (subsys != sys) {
1153 		mutex_unlock(&vml_mutex);
1154 		return;
1155 	}
1156 	subsys->restore(subsys);
1157 	subsys = NULL;
1158 	list_for_each_entry_safe(entry, next, &global_has_mode, head) {
1159 		printk(KERN_DEBUG MODULE_NAME ": subsys disable pipe\n");
1160 		vmlfb_disable_pipe(entry);
1161 		list_move_tail(&entry->head, &global_no_mode);
1162 	}
1163 	mutex_unlock(&vml_mutex);
1164 }
1165 
1166 EXPORT_SYMBOL_GPL(vmlfb_unregister_subsys);
1167 
1168 module_init(vmlfb_init);
1169 module_exit(vmlfb_cleanup);
1170 
1171 MODULE_AUTHOR("Tungsten Graphics");
1172 MODULE_DESCRIPTION("Initialization of the Vermilion display devices");
1173 MODULE_VERSION("1.0.0");
1174 MODULE_LICENSE("GPL");
1175