1 /**************************************************************************
2 * Copyright (c) 2007-2011, Intel Corporation.
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms and conditions of the GNU General Public License,
7 * version 2, as published by the Free Software Foundation.
9 * This program is distributed in the hope it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
14 * You should have received a copy of the GNU General Public License along with
15 * this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
18 **************************************************************************/
20 #include <linux/module.h>
21 #include <linux/kernel.h>
22 #include <linux/errno.h>
23 #include <linux/string.h>
25 #include <linux/tty.h>
26 #include <linux/slab.h>
27 #include <linux/delay.h>
29 #include <linux/init.h>
30 #include <linux/console.h>
34 #include <drm/drm_crtc.h>
35 #include <drm/drm_fb_helper.h>
38 #include "psb_intel_reg.h"
39 #include "psb_intel_drv.h"
40 #include "framebuffer.h"
43 static void psb_user_framebuffer_destroy(struct drm_framebuffer
*fb
);
44 static int psb_user_framebuffer_create_handle(struct drm_framebuffer
*fb
,
45 struct drm_file
*file_priv
,
46 unsigned int *handle
);
48 static const struct drm_framebuffer_funcs psb_fb_funcs
= {
49 .destroy
= psb_user_framebuffer_destroy
,
50 .create_handle
= psb_user_framebuffer_create_handle
,
53 #define CMAP_TOHW(_val, _width) ((((_val) << (_width)) + 0x7FFF - (_val)) >> 16)
55 static int psbfb_setcolreg(unsigned regno
, unsigned red
, unsigned green
,
56 unsigned blue
, unsigned transp
,
59 struct psb_fbdev
*fbdev
= info
->par
;
60 struct drm_framebuffer
*fb
= fbdev
->psb_fb_helper
.fb
;
69 red
= CMAP_TOHW(red
, info
->var
.red
.length
);
70 blue
= CMAP_TOHW(blue
, info
->var
.blue
.length
);
71 green
= CMAP_TOHW(green
, info
->var
.green
.length
);
72 transp
= CMAP_TOHW(transp
, info
->var
.transp
.length
);
74 v
= (red
<< info
->var
.red
.offset
) |
75 (green
<< info
->var
.green
.offset
) |
76 (blue
<< info
->var
.blue
.offset
) |
77 (transp
<< info
->var
.transp
.offset
);
80 switch (fb
->bits_per_pixel
) {
82 ((uint32_t *) info
->pseudo_palette
)[regno
] = v
;
86 ((uint32_t *) info
->pseudo_palette
)[regno
] = v
;
94 static int psbfb_pan(struct fb_var_screeninfo
*var
, struct fb_info
*info
)
96 struct psb_fbdev
*fbdev
= info
->par
;
97 struct psb_framebuffer
*psbfb
= &fbdev
->pfb
;
98 struct drm_device
*dev
= psbfb
->base
.dev
;
101 * We have to poke our nose in here. The core fb code assumes
102 * panning is part of the hardware that can be invoked before
103 * the actual fb is mapped. In our case that isn't quite true.
105 if (psbfb
->gtt
->npage
) {
106 /* GTT roll shifts in 4K pages, we need to shift the right
108 int pages
= info
->fix
.line_length
>> 12;
109 psb_gtt_roll(dev
, psbfb
->gtt
, var
->yoffset
* pages
);
114 void psbfb_suspend(struct drm_device
*dev
)
116 struct drm_framebuffer
*fb
;
119 mutex_lock(&dev
->mode_config
.mutex
);
120 list_for_each_entry(fb
, &dev
->mode_config
.fb_list
, head
) {
121 struct psb_framebuffer
*psbfb
= to_psb_fb(fb
);
122 struct fb_info
*info
= psbfb
->fbdev
;
123 fb_set_suspend(info
, 1);
124 drm_fb_helper_blank(FB_BLANK_POWERDOWN
, info
);
126 mutex_unlock(&dev
->mode_config
.mutex
);
130 void psbfb_resume(struct drm_device
*dev
)
132 struct drm_framebuffer
*fb
;
135 mutex_lock(&dev
->mode_config
.mutex
);
136 list_for_each_entry(fb
, &dev
->mode_config
.fb_list
, head
) {
137 struct psb_framebuffer
*psbfb
= to_psb_fb(fb
);
138 struct fb_info
*info
= psbfb
->fbdev
;
139 fb_set_suspend(info
, 0);
140 drm_fb_helper_blank(FB_BLANK_UNBLANK
, info
);
142 mutex_unlock(&dev
->mode_config
.mutex
);
144 drm_helper_disable_unused_functions(dev
);
147 static int psbfb_vm_fault(struct vm_area_struct
*vma
, struct vm_fault
*vmf
)
149 struct psb_framebuffer
*psbfb
= vma
->vm_private_data
;
150 struct drm_device
*dev
= psbfb
->base
.dev
;
151 struct drm_psb_private
*dev_priv
= dev
->dev_private
;
154 unsigned long address
;
157 /* FIXME: assumes fb at stolen base which may not be true */
158 unsigned long phys_addr
= (unsigned long)dev_priv
->stolen_base
;
160 page_num
= (vma
->vm_end
- vma
->vm_start
) >> PAGE_SHIFT
;
161 address
= (unsigned long)vmf
->virtual_address
;
163 vma
->vm_page_prot
= pgprot_noncached(vma
->vm_page_prot
);
165 for (i
= 0; i
< page_num
; i
++) {
166 pfn
= (phys_addr
>> PAGE_SHIFT
);
168 ret
= vm_insert_mixed(vma
, address
, pfn
);
169 if (unlikely((ret
== -EBUSY
) || (ret
!= 0 && i
> 0)))
171 else if (unlikely(ret
!= 0)) {
172 ret
= (ret
== -ENOMEM
) ? VM_FAULT_OOM
: VM_FAULT_SIGBUS
;
175 address
+= PAGE_SIZE
;
176 phys_addr
+= PAGE_SIZE
;
178 return VM_FAULT_NOPAGE
;
181 static void psbfb_vm_open(struct vm_area_struct
*vma
)
185 static void psbfb_vm_close(struct vm_area_struct
*vma
)
189 static struct vm_operations_struct psbfb_vm_ops
= {
190 .fault
= psbfb_vm_fault
,
191 .open
= psbfb_vm_open
,
192 .close
= psbfb_vm_close
195 static int psbfb_mmap(struct fb_info
*info
, struct vm_area_struct
*vma
)
197 struct psb_fbdev
*fbdev
= info
->par
;
198 struct psb_framebuffer
*psbfb
= &fbdev
->pfb
;
200 if (vma
->vm_pgoff
!= 0)
202 if (vma
->vm_pgoff
> (~0UL >> PAGE_SHIFT
))
205 if (!psbfb
->addr_space
)
206 psbfb
->addr_space
= vma
->vm_file
->f_mapping
;
208 * If this is a GEM object then info->screen_base is the virtual
209 * kernel remapping of the object. FIXME: Review if this is
210 * suitable for our mmap work
212 vma
->vm_ops
= &psbfb_vm_ops
;
213 vma
->vm_private_data
= (void *)psbfb
;
214 vma
->vm_flags
|= VM_RESERVED
| VM_IO
|
215 VM_MIXEDMAP
| VM_DONTEXPAND
;
219 static int psbfb_ioctl(struct fb_info
*info
, unsigned int cmd
,
225 static struct fb_ops psbfb_ops
= {
226 .owner
= THIS_MODULE
,
227 .fb_check_var
= drm_fb_helper_check_var
,
228 .fb_set_par
= drm_fb_helper_set_par
,
229 .fb_blank
= drm_fb_helper_blank
,
230 .fb_setcolreg
= psbfb_setcolreg
,
231 .fb_fillrect
= cfb_fillrect
,
232 .fb_copyarea
= psbfb_copyarea
,
233 .fb_imageblit
= cfb_imageblit
,
234 .fb_mmap
= psbfb_mmap
,
235 .fb_sync
= psbfb_sync
,
236 .fb_ioctl
= psbfb_ioctl
,
239 static struct fb_ops psbfb_roll_ops
= {
240 .owner
= THIS_MODULE
,
241 .fb_check_var
= drm_fb_helper_check_var
,
242 .fb_set_par
= drm_fb_helper_set_par
,
243 .fb_blank
= drm_fb_helper_blank
,
244 .fb_setcolreg
= psbfb_setcolreg
,
245 .fb_fillrect
= cfb_fillrect
,
246 .fb_copyarea
= cfb_copyarea
,
247 .fb_imageblit
= cfb_imageblit
,
248 .fb_pan_display
= psbfb_pan
,
249 .fb_mmap
= psbfb_mmap
,
250 .fb_sync
= psbfb_sync
,
251 .fb_ioctl
= psbfb_ioctl
,
254 static struct fb_ops psbfb_unaccel_ops
= {
255 .owner
= THIS_MODULE
,
256 .fb_check_var
= drm_fb_helper_check_var
,
257 .fb_set_par
= drm_fb_helper_set_par
,
258 .fb_blank
= drm_fb_helper_blank
,
259 .fb_setcolreg
= psbfb_setcolreg
,
260 .fb_fillrect
= cfb_fillrect
,
261 .fb_copyarea
= cfb_copyarea
,
262 .fb_imageblit
= cfb_imageblit
,
263 .fb_mmap
= psbfb_mmap
,
264 .fb_ioctl
= psbfb_ioctl
,
268 * psb_framebuffer_init - initialize a framebuffer
269 * @dev: our DRM device
270 * @fb: framebuffer to set up
271 * @mode_cmd: mode description
272 * @gt: backing object
274 * Configure and fill in the boilerplate for our frame buffer. Return
275 * 0 on success or an error code if we fail.
277 static int psb_framebuffer_init(struct drm_device
*dev
,
278 struct psb_framebuffer
*fb
,
279 struct drm_mode_fb_cmd2
*mode_cmd
,
280 struct gtt_range
*gt
)
285 drm_fb_get_bpp_depth(mode_cmd
->pixel_format
, &depth
, &bpp
);
287 if (mode_cmd
->pitches
[0] & 63)
298 ret
= drm_framebuffer_init(dev
, &fb
->base
, &psb_fb_funcs
);
300 dev_err(dev
->dev
, "framebuffer init failed: %d\n", ret
);
303 drm_helper_mode_fill_fb_struct(&fb
->base
, mode_cmd
);
309 * psb_framebuffer_create - create a framebuffer backed by gt
310 * @dev: our DRM device
311 * @mode_cmd: the description of the requested mode
312 * @gt: the backing object
314 * Create a framebuffer object backed by the gt, and fill in the
315 * boilerplate required
317 * TODO: review object references
320 static struct drm_framebuffer
*psb_framebuffer_create
321 (struct drm_device
*dev
,
322 struct drm_mode_fb_cmd2
*mode_cmd
,
323 struct gtt_range
*gt
)
325 struct psb_framebuffer
*fb
;
328 fb
= kzalloc(sizeof(*fb
), GFP_KERNEL
);
330 return ERR_PTR(-ENOMEM
);
332 ret
= psb_framebuffer_init(dev
, fb
, mode_cmd
, gt
);
341 * psbfb_alloc - allocate frame buffer memory
342 * @dev: the DRM device
343 * @aligned_size: space needed
344 * @force: fall back to GEM buffers if need be
346 * Allocate the frame buffer. In the usual case we get a GTT range that
347 * is stolen memory backed and life is simple. If there isn't sufficient
348 * we fail as we don't have the virtual mapping space to really vmap it
349 * and the kernel console code can't handle non linear framebuffers.
351 * Re-address this as and if the framebuffer layer grows this ability.
353 static struct gtt_range
*psbfb_alloc(struct drm_device
*dev
, int aligned_size
)
355 struct gtt_range
*backing
;
356 /* Begin by trying to use stolen memory backing */
357 backing
= psb_gtt_alloc_range(dev
, aligned_size
, "fb", 1);
359 if (drm_gem_private_object_init(dev
,
360 &backing
->gem
, aligned_size
) == 0)
362 psb_gtt_free_range(dev
, backing
);
368 * psbfb_create - create a framebuffer
369 * @fbdev: the framebuffer device
370 * @sizes: specification of the layout
372 * Create a framebuffer to the specifications provided
374 static int psbfb_create(struct psb_fbdev
*fbdev
,
375 struct drm_fb_helper_surface_size
*sizes
)
377 struct drm_device
*dev
= fbdev
->psb_fb_helper
.dev
;
378 struct drm_psb_private
*dev_priv
= dev
->dev_private
;
379 struct fb_info
*info
;
380 struct drm_framebuffer
*fb
;
381 struct psb_framebuffer
*psbfb
= &fbdev
->pfb
;
382 struct drm_mode_fb_cmd2 mode_cmd
;
383 struct device
*device
= &dev
->pdev
->dev
;
386 struct gtt_range
*backing
;
391 mode_cmd
.width
= sizes
->surface_width
;
392 mode_cmd
.height
= sizes
->surface_height
;
393 bpp
= sizes
->surface_bpp
;
394 depth
= sizes
->surface_depth
;
396 /* No 24bit packed */
402 * Acceleration via the GTT requires pitch to be
403 * power of two aligned. Preferably page but less
404 * is ok with some fonts
406 mode_cmd
.pitches
[0] = ALIGN(mode_cmd
.width
* ((bpp
+ 7) / 8), 4096 >> pitch_lines
);
408 size
= mode_cmd
.pitches
[0] * mode_cmd
.height
;
409 size
= ALIGN(size
, PAGE_SIZE
);
411 /* Allocate the fb in the GTT with stolen page backing */
412 backing
= psbfb_alloc(dev
, size
);
419 } while (backing
== NULL
&& pitch_lines
<= 16);
421 /* The final pitch we accepted if we succeeded */
424 if (backing
== NULL
) {
426 * We couldn't get the space we wanted, fall back to the
427 * display engine requirement instead. The HW requires
428 * the pitch to be 64 byte aligned
431 gtt_roll
= 0; /* Don't use GTT accelerated scrolling */
434 mode_cmd
.pitches
[0] = ALIGN(mode_cmd
.width
* ((bpp
+ 7) / 8), 64);
436 size
= mode_cmd
.pitches
[0] * mode_cmd
.height
;
437 size
= ALIGN(size
, PAGE_SIZE
);
439 /* Allocate the framebuffer in the GTT with stolen page backing */
440 backing
= psbfb_alloc(dev
, size
);
445 mutex_lock(&dev
->struct_mutex
);
447 info
= framebuffer_alloc(0, device
);
454 mode_cmd
.pixel_format
= drm_mode_legacy_fb_format(bpp
, depth
);
456 ret
= psb_framebuffer_init(dev
, psbfb
, &mode_cmd
, backing
);
463 fbdev
->psb_fb_helper
.fb
= fb
;
464 fbdev
->psb_fb_helper
.fbdev
= info
;
466 drm_fb_helper_fill_fix(info
, fb
->pitches
[0], fb
->depth
);
467 strcpy(info
->fix
.id
, "psbfb");
469 info
->flags
= FBINFO_DEFAULT
;
470 if (dev_priv
->ops
->accel_2d
&& pitch_lines
> 8) /* 2D engine */
471 info
->fbops
= &psbfb_ops
;
472 else if (gtt_roll
) { /* GTT rolling seems best */
473 info
->fbops
= &psbfb_roll_ops
;
474 info
->flags
|= FBINFO_HWACCEL_YPAN
;
475 } else /* Software */
476 info
->fbops
= &psbfb_unaccel_ops
;
478 ret
= fb_alloc_cmap(&info
->cmap
, 256, 0);
484 info
->fix
.smem_start
= dev
->mode_config
.fb_base
;
485 info
->fix
.smem_len
= size
;
486 info
->fix
.ywrapstep
= gtt_roll
;
487 info
->fix
.ypanstep
= 0;
489 /* Accessed stolen memory directly */
490 info
->screen_base
= (char *)dev_priv
->vram_addr
+
492 info
->screen_size
= size
;
494 if (dev_priv
->gtt
.stolen_size
) {
495 info
->apertures
= alloc_apertures(1);
496 if (!info
->apertures
) {
500 info
->apertures
->ranges
[0].base
= dev
->mode_config
.fb_base
;
501 info
->apertures
->ranges
[0].size
= dev_priv
->gtt
.stolen_size
;
504 drm_fb_helper_fill_var(info
, &fbdev
->psb_fb_helper
,
505 sizes
->fb_width
, sizes
->fb_height
);
507 info
->fix
.mmio_start
= pci_resource_start(dev
->pdev
, 0);
508 info
->fix
.mmio_len
= pci_resource_len(dev
->pdev
, 0);
510 /* Use default scratch pixmap (info->pixmap.flags = FB_PIXMAP_SYSTEM) */
512 dev_info(dev
->dev
, "allocated %dx%d fb\n",
513 psbfb
->base
.width
, psbfb
->base
.height
);
515 mutex_unlock(&dev
->struct_mutex
);
519 psb_gtt_free_range(dev
, backing
);
521 drm_gem_object_unreference(&backing
->gem
);
523 mutex_unlock(&dev
->struct_mutex
);
524 psb_gtt_free_range(dev
, backing
);
529 * psb_user_framebuffer_create - create framebuffer
530 * @dev: our DRM device
534 * Create a new framebuffer backed by a userspace GEM object
536 static struct drm_framebuffer
*psb_user_framebuffer_create
537 (struct drm_device
*dev
, struct drm_file
*filp
,
538 struct drm_mode_fb_cmd2
*cmd
)
541 struct drm_gem_object
*obj
;
544 * Find the GEM object and thus the gtt range object that is
547 obj
= drm_gem_object_lookup(dev
, filp
, cmd
->handles
[0]);
549 return ERR_PTR(-ENOENT
);
551 /* Let the core code do all the work */
552 r
= container_of(obj
, struct gtt_range
, gem
);
553 return psb_framebuffer_create(dev
, cmd
, r
);
556 static void psbfb_gamma_set(struct drm_crtc
*crtc
, u16 red
, u16 green
,
559 struct psb_intel_crtc
*intel_crtc
= to_psb_intel_crtc(crtc
);
561 intel_crtc
->lut_r
[regno
] = red
>> 8;
562 intel_crtc
->lut_g
[regno
] = green
>> 8;
563 intel_crtc
->lut_b
[regno
] = blue
>> 8;
566 static void psbfb_gamma_get(struct drm_crtc
*crtc
, u16
*red
,
567 u16
*green
, u16
*blue
, int regno
)
569 struct psb_intel_crtc
*intel_crtc
= to_psb_intel_crtc(crtc
);
571 *red
= intel_crtc
->lut_r
[regno
] << 8;
572 *green
= intel_crtc
->lut_g
[regno
] << 8;
573 *blue
= intel_crtc
->lut_b
[regno
] << 8;
576 static int psbfb_probe(struct drm_fb_helper
*helper
,
577 struct drm_fb_helper_surface_size
*sizes
)
579 struct psb_fbdev
*psb_fbdev
= (struct psb_fbdev
*)helper
;
584 ret
= psbfb_create(psb_fbdev
, sizes
);
592 struct drm_fb_helper_funcs psb_fb_helper_funcs
= {
593 .gamma_set
= psbfb_gamma_set
,
594 .gamma_get
= psbfb_gamma_get
,
595 .fb_probe
= psbfb_probe
,
598 int psb_fbdev_destroy(struct drm_device
*dev
, struct psb_fbdev
*fbdev
)
600 struct fb_info
*info
;
601 struct psb_framebuffer
*psbfb
= &fbdev
->pfb
;
603 if (fbdev
->psb_fb_helper
.fbdev
) {
604 info
= fbdev
->psb_fb_helper
.fbdev
;
605 unregister_framebuffer(info
);
607 fb_dealloc_cmap(&info
->cmap
);
608 framebuffer_release(info
);
610 drm_fb_helper_fini(&fbdev
->psb_fb_helper
);
611 drm_framebuffer_cleanup(&psbfb
->base
);
614 drm_gem_object_unreference(&psbfb
->gtt
->gem
);
618 int psb_fbdev_init(struct drm_device
*dev
)
620 struct psb_fbdev
*fbdev
;
621 struct drm_psb_private
*dev_priv
= dev
->dev_private
;
623 fbdev
= kzalloc(sizeof(struct psb_fbdev
), GFP_KERNEL
);
625 dev_err(dev
->dev
, "no memory\n");
629 dev_priv
->fbdev
= fbdev
;
630 fbdev
->psb_fb_helper
.funcs
= &psb_fb_helper_funcs
;
632 drm_fb_helper_init(dev
, &fbdev
->psb_fb_helper
, dev_priv
->ops
->crtcs
,
635 drm_fb_helper_single_add_all_connectors(&fbdev
->psb_fb_helper
);
636 drm_fb_helper_initial_config(&fbdev
->psb_fb_helper
, 32);
640 void psb_fbdev_fini(struct drm_device
*dev
)
642 struct drm_psb_private
*dev_priv
= dev
->dev_private
;
644 if (!dev_priv
->fbdev
)
647 psb_fbdev_destroy(dev
, dev_priv
->fbdev
);
648 kfree(dev_priv
->fbdev
);
649 dev_priv
->fbdev
= NULL
;
652 static void psbfb_output_poll_changed(struct drm_device
*dev
)
654 struct drm_psb_private
*dev_priv
= dev
->dev_private
;
655 struct psb_fbdev
*fbdev
= (struct psb_fbdev
*)dev_priv
->fbdev
;
656 drm_fb_helper_hotplug_event(&fbdev
->psb_fb_helper
);
660 * psb_user_framebuffer_create_handle - add hamdle to a framebuffer
662 * @file_priv: our DRM file
663 * @handle: returned handle
665 * Our framebuffer object is a GTT range which also contains a GEM
666 * object. We need to turn it into a handle for userspace. GEM will do
669 static int psb_user_framebuffer_create_handle(struct drm_framebuffer
*fb
,
670 struct drm_file
*file_priv
,
671 unsigned int *handle
)
673 struct psb_framebuffer
*psbfb
= to_psb_fb(fb
);
674 struct gtt_range
*r
= psbfb
->gtt
;
675 return drm_gem_handle_create(file_priv
, &r
->gem
, handle
);
679 * psb_user_framebuffer_destroy - destruct user created fb
682 * User framebuffers are backed by GEM objects so all we have to do is
683 * clean up a bit and drop the reference, GEM will handle the fallout
685 static void psb_user_framebuffer_destroy(struct drm_framebuffer
*fb
)
687 struct psb_framebuffer
*psbfb
= to_psb_fb(fb
);
688 struct gtt_range
*r
= psbfb
->gtt
;
689 struct drm_device
*dev
= fb
->dev
;
690 struct drm_psb_private
*dev_priv
= dev
->dev_private
;
691 struct psb_fbdev
*fbdev
= dev_priv
->fbdev
;
692 struct drm_crtc
*crtc
;
695 /* Should never get stolen memory for a user fb */
698 /* Check if we are erroneously live */
699 list_for_each_entry(crtc
, &dev
->mode_config
.crtc_list
, head
)
705 * Now force a sane response before we permit the DRM CRTC
706 * layer to do stupid things like blank the display. Instead
707 * we reset this framebuffer as if the user had forced a reset.
708 * We must do this before the cleanup so that the DRM layer
709 * doesn't get a chance to stick its oar in where it isn't
712 drm_fb_helper_restore_fbdev_mode(&fbdev
->psb_fb_helper
);
714 /* Let DRM do its clean up */
715 drm_framebuffer_cleanup(fb
);
716 /* We are no longer using the resource in GEM */
717 drm_gem_object_unreference_unlocked(&r
->gem
);
721 static const struct drm_mode_config_funcs psb_mode_funcs
= {
722 .fb_create
= psb_user_framebuffer_create
,
723 .output_poll_changed
= psbfb_output_poll_changed
,
726 static int psb_create_backlight_property(struct drm_device
*dev
)
728 struct drm_psb_private
*dev_priv
= dev
->dev_private
;
729 struct drm_property
*backlight
;
731 if (dev_priv
->backlight_property
)
734 backlight
= drm_property_create_range(dev
, 0, "backlight", 0, 100);
736 dev_priv
->backlight_property
= backlight
;
741 static void psb_setup_outputs(struct drm_device
*dev
)
743 struct drm_psb_private
*dev_priv
= dev
->dev_private
;
744 struct drm_connector
*connector
;
746 drm_mode_create_scaling_mode_property(dev
);
747 psb_create_backlight_property(dev
);
749 dev_priv
->ops
->output_init(dev
);
751 list_for_each_entry(connector
, &dev
->mode_config
.connector_list
,
753 struct psb_intel_encoder
*psb_intel_encoder
=
754 psb_intel_attached_encoder(connector
);
755 struct drm_encoder
*encoder
= &psb_intel_encoder
->base
;
756 int crtc_mask
= 0, clone_mask
= 0;
759 switch (psb_intel_encoder
->type
) {
760 case INTEL_OUTPUT_ANALOG
:
761 crtc_mask
= (1 << 0);
762 clone_mask
= (1 << INTEL_OUTPUT_ANALOG
);
764 case INTEL_OUTPUT_SDVO
:
765 crtc_mask
= ((1 << 0) | (1 << 1));
766 clone_mask
= (1 << INTEL_OUTPUT_SDVO
);
768 case INTEL_OUTPUT_LVDS
:
770 crtc_mask
= (1 << 0);
772 crtc_mask
= (1 << 1);
773 clone_mask
= (1 << INTEL_OUTPUT_LVDS
);
775 case INTEL_OUTPUT_MIPI
:
776 crtc_mask
= (1 << 0);
777 clone_mask
= (1 << INTEL_OUTPUT_MIPI
);
779 case INTEL_OUTPUT_MIPI2
:
780 crtc_mask
= (1 << 2);
781 clone_mask
= (1 << INTEL_OUTPUT_MIPI2
);
783 case INTEL_OUTPUT_HDMI
:
785 crtc_mask
= (1 << 1);
787 crtc_mask
= (1 << 0);
788 clone_mask
= (1 << INTEL_OUTPUT_HDMI
);
791 encoder
->possible_crtcs
= crtc_mask
;
792 encoder
->possible_clones
=
793 psb_intel_connector_clones(dev
, clone_mask
);
797 void psb_modeset_init(struct drm_device
*dev
)
799 struct drm_psb_private
*dev_priv
= dev
->dev_private
;
800 struct psb_intel_mode_device
*mode_dev
= &dev_priv
->mode_dev
;
803 drm_mode_config_init(dev
);
805 dev
->mode_config
.min_width
= 0;
806 dev
->mode_config
.min_height
= 0;
808 dev
->mode_config
.funcs
= (void *) &psb_mode_funcs
;
810 /* set memory base */
811 /* Oaktrail and Poulsbo should use BAR 2*/
812 pci_read_config_dword(dev
->pdev
, PSB_BSM
, (u32
*)
813 &(dev
->mode_config
.fb_base
));
815 /* num pipes is 2 for PSB but 1 for Mrst */
816 for (i
= 0; i
< dev_priv
->num_pipe
; i
++)
817 psb_intel_crtc_init(dev
, i
, mode_dev
);
819 dev
->mode_config
.max_width
= 2048;
820 dev
->mode_config
.max_height
= 2048;
822 psb_setup_outputs(dev
);
825 void psb_modeset_cleanup(struct drm_device
*dev
)
827 mutex_lock(&dev
->struct_mutex
);
829 drm_kms_helper_poll_fini(dev
);
831 drm_mode_config_cleanup(dev
);
833 mutex_unlock(&dev
->struct_mutex
);