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>
24 #include <linux/pfn_t.h>
26 #include <linux/tty.h>
27 #include <linux/slab.h>
28 #include <linux/delay.h>
30 #include <linux/init.h>
31 #include <linux/console.h>
35 #include <drm/drm_crtc.h>
36 #include <drm/drm_fb_helper.h>
39 #include "psb_intel_reg.h"
40 #include "psb_intel_drv.h"
41 #include "framebuffer.h"
44 static void psb_user_framebuffer_destroy(struct drm_framebuffer
*fb
);
45 static int psb_user_framebuffer_create_handle(struct drm_framebuffer
*fb
,
46 struct drm_file
*file_priv
,
47 unsigned int *handle
);
49 static const struct drm_framebuffer_funcs psb_fb_funcs
= {
50 .destroy
= psb_user_framebuffer_destroy
,
51 .create_handle
= psb_user_framebuffer_create_handle
,
54 #define CMAP_TOHW(_val, _width) ((((_val) << (_width)) + 0x7FFF - (_val)) >> 16)
56 static int psbfb_setcolreg(unsigned regno
, unsigned red
, unsigned green
,
57 unsigned blue
, unsigned transp
,
60 struct psb_fbdev
*fbdev
= info
->par
;
61 struct drm_framebuffer
*fb
= fbdev
->psb_fb_helper
.fb
;
70 red
= CMAP_TOHW(red
, info
->var
.red
.length
);
71 blue
= CMAP_TOHW(blue
, info
->var
.blue
.length
);
72 green
= CMAP_TOHW(green
, info
->var
.green
.length
);
73 transp
= CMAP_TOHW(transp
, info
->var
.transp
.length
);
75 v
= (red
<< info
->var
.red
.offset
) |
76 (green
<< info
->var
.green
.offset
) |
77 (blue
<< info
->var
.blue
.offset
) |
78 (transp
<< info
->var
.transp
.offset
);
81 switch (fb
->bits_per_pixel
) {
83 ((uint32_t *) info
->pseudo_palette
)[regno
] = v
;
87 ((uint32_t *) info
->pseudo_palette
)[regno
] = v
;
95 static int psbfb_pan(struct fb_var_screeninfo
*var
, struct fb_info
*info
)
97 struct psb_fbdev
*fbdev
= info
->par
;
98 struct psb_framebuffer
*psbfb
= &fbdev
->pfb
;
99 struct drm_device
*dev
= psbfb
->base
.dev
;
102 * We have to poke our nose in here. The core fb code assumes
103 * panning is part of the hardware that can be invoked before
104 * the actual fb is mapped. In our case that isn't quite true.
106 if (psbfb
->gtt
->npage
) {
107 /* GTT roll shifts in 4K pages, we need to shift the right
109 int pages
= info
->fix
.line_length
>> 12;
110 psb_gtt_roll(dev
, psbfb
->gtt
, var
->yoffset
* pages
);
115 static int psbfb_vm_fault(struct vm_area_struct
*vma
, struct vm_fault
*vmf
)
117 struct psb_framebuffer
*psbfb
= vma
->vm_private_data
;
118 struct drm_device
*dev
= psbfb
->base
.dev
;
119 struct drm_psb_private
*dev_priv
= dev
->dev_private
;
122 unsigned long address
;
125 unsigned long phys_addr
= (unsigned long)dev_priv
->stolen_base
+
128 page_num
= (vma
->vm_end
- vma
->vm_start
) >> PAGE_SHIFT
;
129 address
= (unsigned long)vmf
->virtual_address
- (vmf
->pgoff
<< PAGE_SHIFT
);
131 vma
->vm_page_prot
= pgprot_noncached(vma
->vm_page_prot
);
133 for (i
= 0; i
< page_num
; i
++) {
134 pfn
= (phys_addr
>> PAGE_SHIFT
);
136 ret
= vm_insert_mixed(vma
, address
,
137 __pfn_to_pfn_t(pfn
, PFN_DEV
));
138 if (unlikely((ret
== -EBUSY
) || (ret
!= 0 && i
> 0)))
140 else if (unlikely(ret
!= 0)) {
141 ret
= (ret
== -ENOMEM
) ? VM_FAULT_OOM
: VM_FAULT_SIGBUS
;
144 address
+= PAGE_SIZE
;
145 phys_addr
+= PAGE_SIZE
;
147 return VM_FAULT_NOPAGE
;
150 static void psbfb_vm_open(struct vm_area_struct
*vma
)
154 static void psbfb_vm_close(struct vm_area_struct
*vma
)
158 static const struct vm_operations_struct psbfb_vm_ops
= {
159 .fault
= psbfb_vm_fault
,
160 .open
= psbfb_vm_open
,
161 .close
= psbfb_vm_close
164 static int psbfb_mmap(struct fb_info
*info
, struct vm_area_struct
*vma
)
166 struct psb_fbdev
*fbdev
= info
->par
;
167 struct psb_framebuffer
*psbfb
= &fbdev
->pfb
;
169 if (vma
->vm_pgoff
!= 0)
171 if (vma
->vm_pgoff
> (~0UL >> PAGE_SHIFT
))
174 if (!psbfb
->addr_space
)
175 psbfb
->addr_space
= vma
->vm_file
->f_mapping
;
177 * If this is a GEM object then info->screen_base is the virtual
178 * kernel remapping of the object. FIXME: Review if this is
179 * suitable for our mmap work
181 vma
->vm_ops
= &psbfb_vm_ops
;
182 vma
->vm_private_data
= (void *)psbfb
;
183 vma
->vm_flags
|= VM_IO
| VM_MIXEDMAP
| VM_DONTEXPAND
| VM_DONTDUMP
;
187 static struct fb_ops psbfb_ops
= {
188 .owner
= THIS_MODULE
,
189 .fb_check_var
= drm_fb_helper_check_var
,
190 .fb_set_par
= drm_fb_helper_set_par
,
191 .fb_blank
= drm_fb_helper_blank
,
192 .fb_setcolreg
= psbfb_setcolreg
,
193 .fb_fillrect
= drm_fb_helper_cfb_fillrect
,
194 .fb_copyarea
= psbfb_copyarea
,
195 .fb_imageblit
= drm_fb_helper_cfb_imageblit
,
196 .fb_mmap
= psbfb_mmap
,
197 .fb_sync
= psbfb_sync
,
200 static struct fb_ops psbfb_roll_ops
= {
201 .owner
= THIS_MODULE
,
202 .fb_check_var
= drm_fb_helper_check_var
,
203 .fb_set_par
= drm_fb_helper_set_par
,
204 .fb_blank
= drm_fb_helper_blank
,
205 .fb_setcolreg
= psbfb_setcolreg
,
206 .fb_fillrect
= drm_fb_helper_cfb_fillrect
,
207 .fb_copyarea
= drm_fb_helper_cfb_copyarea
,
208 .fb_imageblit
= drm_fb_helper_cfb_imageblit
,
209 .fb_pan_display
= psbfb_pan
,
210 .fb_mmap
= psbfb_mmap
,
213 static struct fb_ops psbfb_unaccel_ops
= {
214 .owner
= THIS_MODULE
,
215 .fb_check_var
= drm_fb_helper_check_var
,
216 .fb_set_par
= drm_fb_helper_set_par
,
217 .fb_blank
= drm_fb_helper_blank
,
218 .fb_setcolreg
= psbfb_setcolreg
,
219 .fb_fillrect
= drm_fb_helper_cfb_fillrect
,
220 .fb_copyarea
= drm_fb_helper_cfb_copyarea
,
221 .fb_imageblit
= drm_fb_helper_cfb_imageblit
,
222 .fb_mmap
= psbfb_mmap
,
226 * psb_framebuffer_init - initialize a framebuffer
227 * @dev: our DRM device
228 * @fb: framebuffer to set up
229 * @mode_cmd: mode description
230 * @gt: backing object
232 * Configure and fill in the boilerplate for our frame buffer. Return
233 * 0 on success or an error code if we fail.
235 static int psb_framebuffer_init(struct drm_device
*dev
,
236 struct psb_framebuffer
*fb
,
237 const struct drm_mode_fb_cmd2
*mode_cmd
,
238 struct gtt_range
*gt
)
243 drm_fb_get_bpp_depth(mode_cmd
->pixel_format
, &depth
, &bpp
);
245 if (mode_cmd
->pitches
[0] & 63)
256 drm_helper_mode_fill_fb_struct(&fb
->base
, mode_cmd
);
258 ret
= drm_framebuffer_init(dev
, &fb
->base
, &psb_fb_funcs
);
260 dev_err(dev
->dev
, "framebuffer init failed: %d\n", ret
);
267 * psb_framebuffer_create - create a framebuffer backed by gt
268 * @dev: our DRM device
269 * @mode_cmd: the description of the requested mode
270 * @gt: the backing object
272 * Create a framebuffer object backed by the gt, and fill in the
273 * boilerplate required
275 * TODO: review object references
278 static struct drm_framebuffer
*psb_framebuffer_create
279 (struct drm_device
*dev
,
280 const struct drm_mode_fb_cmd2
*mode_cmd
,
281 struct gtt_range
*gt
)
283 struct psb_framebuffer
*fb
;
286 fb
= kzalloc(sizeof(*fb
), GFP_KERNEL
);
288 return ERR_PTR(-ENOMEM
);
290 ret
= psb_framebuffer_init(dev
, fb
, mode_cmd
, gt
);
299 * psbfb_alloc - allocate frame buffer memory
300 * @dev: the DRM device
301 * @aligned_size: space needed
302 * @force: fall back to GEM buffers if need be
304 * Allocate the frame buffer. In the usual case we get a GTT range that
305 * is stolen memory backed and life is simple. If there isn't sufficient
306 * we fail as we don't have the virtual mapping space to really vmap it
307 * and the kernel console code can't handle non linear framebuffers.
309 * Re-address this as and if the framebuffer layer grows this ability.
311 static struct gtt_range
*psbfb_alloc(struct drm_device
*dev
, int aligned_size
)
313 struct gtt_range
*backing
;
314 /* Begin by trying to use stolen memory backing */
315 backing
= psb_gtt_alloc_range(dev
, aligned_size
, "fb", 1, PAGE_SIZE
);
317 drm_gem_private_object_init(dev
, &backing
->gem
, aligned_size
);
324 * psbfb_create - create a framebuffer
325 * @fbdev: the framebuffer device
326 * @sizes: specification of the layout
328 * Create a framebuffer to the specifications provided
330 static int psbfb_create(struct psb_fbdev
*fbdev
,
331 struct drm_fb_helper_surface_size
*sizes
)
333 struct drm_device
*dev
= fbdev
->psb_fb_helper
.dev
;
334 struct drm_psb_private
*dev_priv
= dev
->dev_private
;
335 struct fb_info
*info
;
336 struct drm_framebuffer
*fb
;
337 struct psb_framebuffer
*psbfb
= &fbdev
->pfb
;
338 struct drm_mode_fb_cmd2 mode_cmd
;
341 struct gtt_range
*backing
;
346 mode_cmd
.width
= sizes
->surface_width
;
347 mode_cmd
.height
= sizes
->surface_height
;
348 bpp
= sizes
->surface_bpp
;
349 depth
= sizes
->surface_depth
;
351 /* No 24bit packed */
357 * Acceleration via the GTT requires pitch to be
358 * power of two aligned. Preferably page but less
359 * is ok with some fonts
361 mode_cmd
.pitches
[0] = ALIGN(mode_cmd
.width
* ((bpp
+ 7) / 8), 4096 >> pitch_lines
);
363 size
= mode_cmd
.pitches
[0] * mode_cmd
.height
;
364 size
= ALIGN(size
, PAGE_SIZE
);
366 /* Allocate the fb in the GTT with stolen page backing */
367 backing
= psbfb_alloc(dev
, size
);
374 } while (backing
== NULL
&& pitch_lines
<= 16);
376 /* The final pitch we accepted if we succeeded */
379 if (backing
== NULL
) {
381 * We couldn't get the space we wanted, fall back to the
382 * display engine requirement instead. The HW requires
383 * the pitch to be 64 byte aligned
386 gtt_roll
= 0; /* Don't use GTT accelerated scrolling */
389 mode_cmd
.pitches
[0] = ALIGN(mode_cmd
.width
* ((bpp
+ 7) / 8), 64);
391 size
= mode_cmd
.pitches
[0] * mode_cmd
.height
;
392 size
= ALIGN(size
, PAGE_SIZE
);
394 /* Allocate the framebuffer in the GTT with stolen page backing */
395 backing
= psbfb_alloc(dev
, size
);
400 memset(dev_priv
->vram_addr
+ backing
->offset
, 0, size
);
402 info
= drm_fb_helper_alloc_fbi(&fbdev
->psb_fb_helper
);
409 mode_cmd
.pixel_format
= drm_mode_legacy_fb_format(bpp
, depth
);
411 ret
= psb_framebuffer_init(dev
, psbfb
, &mode_cmd
, backing
);
418 fbdev
->psb_fb_helper
.fb
= fb
;
420 drm_fb_helper_fill_fix(info
, fb
->pitches
[0], fb
->depth
);
421 strcpy(info
->fix
.id
, "psbdrmfb");
423 info
->flags
= FBINFO_DEFAULT
;
424 if (dev_priv
->ops
->accel_2d
&& pitch_lines
> 8) /* 2D engine */
425 info
->fbops
= &psbfb_ops
;
426 else if (gtt_roll
) { /* GTT rolling seems best */
427 info
->fbops
= &psbfb_roll_ops
;
428 info
->flags
|= FBINFO_HWACCEL_YPAN
;
429 } else /* Software */
430 info
->fbops
= &psbfb_unaccel_ops
;
432 info
->fix
.smem_start
= dev
->mode_config
.fb_base
;
433 info
->fix
.smem_len
= size
;
434 info
->fix
.ywrapstep
= gtt_roll
;
435 info
->fix
.ypanstep
= 0;
437 /* Accessed stolen memory directly */
438 info
->screen_base
= dev_priv
->vram_addr
+ backing
->offset
;
439 info
->screen_size
= size
;
441 if (dev_priv
->gtt
.stolen_size
) {
442 info
->apertures
->ranges
[0].base
= dev
->mode_config
.fb_base
;
443 info
->apertures
->ranges
[0].size
= dev_priv
->gtt
.stolen_size
;
446 drm_fb_helper_fill_var(info
, &fbdev
->psb_fb_helper
,
447 sizes
->fb_width
, sizes
->fb_height
);
449 info
->fix
.mmio_start
= pci_resource_start(dev
->pdev
, 0);
450 info
->fix
.mmio_len
= pci_resource_len(dev
->pdev
, 0);
452 /* Use default scratch pixmap (info->pixmap.flags = FB_PIXMAP_SYSTEM) */
454 dev_dbg(dev
->dev
, "allocated %dx%d fb\n",
455 psbfb
->base
.width
, psbfb
->base
.height
);
459 drm_fb_helper_release_fbi(&fbdev
->psb_fb_helper
);
461 psb_gtt_free_range(dev
, backing
);
466 * psb_user_framebuffer_create - create framebuffer
467 * @dev: our DRM device
471 * Create a new framebuffer backed by a userspace GEM object
473 static struct drm_framebuffer
*psb_user_framebuffer_create
474 (struct drm_device
*dev
, struct drm_file
*filp
,
475 const struct drm_mode_fb_cmd2
*cmd
)
478 struct drm_gem_object
*obj
;
481 * Find the GEM object and thus the gtt range object that is
484 obj
= drm_gem_object_lookup(filp
, cmd
->handles
[0]);
486 return ERR_PTR(-ENOENT
);
488 /* Let the core code do all the work */
489 r
= container_of(obj
, struct gtt_range
, gem
);
490 return psb_framebuffer_create(dev
, cmd
, r
);
493 static void psbfb_gamma_set(struct drm_crtc
*crtc
, u16 red
, u16 green
,
496 struct gma_crtc
*gma_crtc
= to_gma_crtc(crtc
);
498 gma_crtc
->lut_r
[regno
] = red
>> 8;
499 gma_crtc
->lut_g
[regno
] = green
>> 8;
500 gma_crtc
->lut_b
[regno
] = blue
>> 8;
503 static void psbfb_gamma_get(struct drm_crtc
*crtc
, u16
*red
,
504 u16
*green
, u16
*blue
, int regno
)
506 struct gma_crtc
*gma_crtc
= to_gma_crtc(crtc
);
508 *red
= gma_crtc
->lut_r
[regno
] << 8;
509 *green
= gma_crtc
->lut_g
[regno
] << 8;
510 *blue
= gma_crtc
->lut_b
[regno
] << 8;
513 static int psbfb_probe(struct drm_fb_helper
*helper
,
514 struct drm_fb_helper_surface_size
*sizes
)
516 struct psb_fbdev
*psb_fbdev
=
517 container_of(helper
, struct psb_fbdev
, psb_fb_helper
);
518 struct drm_device
*dev
= psb_fbdev
->psb_fb_helper
.dev
;
519 struct drm_psb_private
*dev_priv
= dev
->dev_private
;
522 bytespp
= sizes
->surface_bpp
/ 8;
523 if (bytespp
== 3) /* no 24bit packed */
526 /* If the mode will not fit in 32bit then switch to 16bit to get
527 a console on full resolution. The X mode setting server will
528 allocate its own 32bit GEM framebuffer */
529 if (ALIGN(sizes
->fb_width
* bytespp
, 64) * sizes
->fb_height
>
530 dev_priv
->vram_stolen_size
) {
531 sizes
->surface_bpp
= 16;
532 sizes
->surface_depth
= 16;
535 return psbfb_create(psb_fbdev
, sizes
);
538 static const struct drm_fb_helper_funcs psb_fb_helper_funcs
= {
539 .gamma_set
= psbfb_gamma_set
,
540 .gamma_get
= psbfb_gamma_get
,
541 .fb_probe
= psbfb_probe
,
544 static int psb_fbdev_destroy(struct drm_device
*dev
, struct psb_fbdev
*fbdev
)
546 struct psb_framebuffer
*psbfb
= &fbdev
->pfb
;
548 drm_fb_helper_unregister_fbi(&fbdev
->psb_fb_helper
);
549 drm_fb_helper_release_fbi(&fbdev
->psb_fb_helper
);
551 drm_fb_helper_fini(&fbdev
->psb_fb_helper
);
552 drm_framebuffer_unregister_private(&psbfb
->base
);
553 drm_framebuffer_cleanup(&psbfb
->base
);
556 drm_gem_object_unreference_unlocked(&psbfb
->gtt
->gem
);
560 int psb_fbdev_init(struct drm_device
*dev
)
562 struct psb_fbdev
*fbdev
;
563 struct drm_psb_private
*dev_priv
= dev
->dev_private
;
566 fbdev
= kzalloc(sizeof(struct psb_fbdev
), GFP_KERNEL
);
568 dev_err(dev
->dev
, "no memory\n");
572 dev_priv
->fbdev
= fbdev
;
574 drm_fb_helper_prepare(dev
, &fbdev
->psb_fb_helper
, &psb_fb_helper_funcs
);
576 ret
= drm_fb_helper_init(dev
, &fbdev
->psb_fb_helper
,
577 dev_priv
->ops
->crtcs
, INTELFB_CONN_LIMIT
);
581 ret
= drm_fb_helper_single_add_all_connectors(&fbdev
->psb_fb_helper
);
585 /* disable all the possible outputs/crtcs before entering KMS mode */
586 drm_helper_disable_unused_functions(dev
);
588 ret
= drm_fb_helper_initial_config(&fbdev
->psb_fb_helper
, 32);
595 drm_fb_helper_fini(&fbdev
->psb_fb_helper
);
601 static void psb_fbdev_fini(struct drm_device
*dev
)
603 struct drm_psb_private
*dev_priv
= dev
->dev_private
;
605 if (!dev_priv
->fbdev
)
608 psb_fbdev_destroy(dev
, dev_priv
->fbdev
);
609 kfree(dev_priv
->fbdev
);
610 dev_priv
->fbdev
= NULL
;
613 static void psbfb_output_poll_changed(struct drm_device
*dev
)
615 struct drm_psb_private
*dev_priv
= dev
->dev_private
;
616 struct psb_fbdev
*fbdev
= (struct psb_fbdev
*)dev_priv
->fbdev
;
617 drm_fb_helper_hotplug_event(&fbdev
->psb_fb_helper
);
621 * psb_user_framebuffer_create_handle - add hamdle to a framebuffer
623 * @file_priv: our DRM file
624 * @handle: returned handle
626 * Our framebuffer object is a GTT range which also contains a GEM
627 * object. We need to turn it into a handle for userspace. GEM will do
630 static int psb_user_framebuffer_create_handle(struct drm_framebuffer
*fb
,
631 struct drm_file
*file_priv
,
632 unsigned int *handle
)
634 struct psb_framebuffer
*psbfb
= to_psb_fb(fb
);
635 struct gtt_range
*r
= psbfb
->gtt
;
636 return drm_gem_handle_create(file_priv
, &r
->gem
, handle
);
640 * psb_user_framebuffer_destroy - destruct user created fb
643 * User framebuffers are backed by GEM objects so all we have to do is
644 * clean up a bit and drop the reference, GEM will handle the fallout
646 static void psb_user_framebuffer_destroy(struct drm_framebuffer
*fb
)
648 struct psb_framebuffer
*psbfb
= to_psb_fb(fb
);
649 struct gtt_range
*r
= psbfb
->gtt
;
651 /* Let DRM do its clean up */
652 drm_framebuffer_cleanup(fb
);
653 /* We are no longer using the resource in GEM */
654 drm_gem_object_unreference_unlocked(&r
->gem
);
658 static const struct drm_mode_config_funcs psb_mode_funcs
= {
659 .fb_create
= psb_user_framebuffer_create
,
660 .output_poll_changed
= psbfb_output_poll_changed
,
663 static void psb_setup_outputs(struct drm_device
*dev
)
665 struct drm_psb_private
*dev_priv
= dev
->dev_private
;
666 struct drm_connector
*connector
;
668 drm_mode_create_scaling_mode_property(dev
);
670 /* It is ok for this to fail - we just don't get backlight control */
671 if (!dev_priv
->backlight_property
)
672 dev_priv
->backlight_property
= drm_property_create_range(dev
, 0,
673 "backlight", 0, 100);
674 dev_priv
->ops
->output_init(dev
);
676 list_for_each_entry(connector
, &dev
->mode_config
.connector_list
,
678 struct gma_encoder
*gma_encoder
= gma_attached_encoder(connector
);
679 struct drm_encoder
*encoder
= &gma_encoder
->base
;
680 int crtc_mask
= 0, clone_mask
= 0;
683 switch (gma_encoder
->type
) {
684 case INTEL_OUTPUT_ANALOG
:
685 crtc_mask
= (1 << 0);
686 clone_mask
= (1 << INTEL_OUTPUT_ANALOG
);
688 case INTEL_OUTPUT_SDVO
:
689 crtc_mask
= dev_priv
->ops
->sdvo_mask
;
690 clone_mask
= (1 << INTEL_OUTPUT_SDVO
);
692 case INTEL_OUTPUT_LVDS
:
693 crtc_mask
= dev_priv
->ops
->lvds_mask
;
694 clone_mask
= (1 << INTEL_OUTPUT_LVDS
);
696 case INTEL_OUTPUT_MIPI
:
697 crtc_mask
= (1 << 0);
698 clone_mask
= (1 << INTEL_OUTPUT_MIPI
);
700 case INTEL_OUTPUT_MIPI2
:
701 crtc_mask
= (1 << 2);
702 clone_mask
= (1 << INTEL_OUTPUT_MIPI2
);
704 case INTEL_OUTPUT_HDMI
:
705 crtc_mask
= dev_priv
->ops
->hdmi_mask
;
706 clone_mask
= (1 << INTEL_OUTPUT_HDMI
);
708 case INTEL_OUTPUT_DISPLAYPORT
:
709 crtc_mask
= (1 << 0) | (1 << 1);
710 clone_mask
= (1 << INTEL_OUTPUT_DISPLAYPORT
);
712 case INTEL_OUTPUT_EDP
:
713 crtc_mask
= (1 << 1);
714 clone_mask
= (1 << INTEL_OUTPUT_EDP
);
716 encoder
->possible_crtcs
= crtc_mask
;
717 encoder
->possible_clones
=
718 gma_connector_clones(dev
, clone_mask
);
722 void psb_modeset_init(struct drm_device
*dev
)
724 struct drm_psb_private
*dev_priv
= dev
->dev_private
;
725 struct psb_intel_mode_device
*mode_dev
= &dev_priv
->mode_dev
;
728 drm_mode_config_init(dev
);
730 dev
->mode_config
.min_width
= 0;
731 dev
->mode_config
.min_height
= 0;
733 dev
->mode_config
.funcs
= &psb_mode_funcs
;
735 /* set memory base */
736 /* Oaktrail and Poulsbo should use BAR 2*/
737 pci_read_config_dword(dev
->pdev
, PSB_BSM
, (u32
*)
738 &(dev
->mode_config
.fb_base
));
740 /* num pipes is 2 for PSB but 1 for Mrst */
741 for (i
= 0; i
< dev_priv
->num_pipe
; i
++)
742 psb_intel_crtc_init(dev
, i
, mode_dev
);
744 dev
->mode_config
.max_width
= 4096;
745 dev
->mode_config
.max_height
= 4096;
747 psb_setup_outputs(dev
);
749 if (dev_priv
->ops
->errata
)
750 dev_priv
->ops
->errata(dev
);
752 dev_priv
->modeset
= true;
755 void psb_modeset_cleanup(struct drm_device
*dev
)
757 struct drm_psb_private
*dev_priv
= dev
->dev_private
;
758 if (dev_priv
->modeset
) {
759 drm_kms_helper_poll_fini(dev
);
761 drm_mode_config_cleanup(dev
);