drivers/staging/gma500/psb_fb.c

   1 /**************************************************************************
   2  * Copyright (c) 2007, Intel Corporation.
   3  * All Rights Reserved.
   4  *
   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.
   8  *
   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
  12  * more details.
  13  *
  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.
  17  *
  18  **************************************************************************/
  19
  20 #include <linux/module.h>
  21 #include <linux/kernel.h>
  22 #include <linux/errno.h>
  23 #include <linux/string.h>
  24 #include <linux/mm.h>
  25 #include <linux/tty.h>
  26 #include <linux/slab.h>
  27 #include <linux/delay.h>
  28 #include <linux/fb.h>
  29 #include <linux/init.h>
  30 #include <linux/console.h>
  31
  32 #include <drm/drmP.h>
  33 #include <drm/drm.h>
  34 #include <drm/drm_crtc.h>
  35
  36 #include "psb_drv.h"
  37 #include "psb_intel_reg.h"
  38 #include "psb_intel_drv.h"
  39 #include "psb_ttm_userobj_api.h"
  40 #include "psb_fb.h"
  41 #include "psb_sgx.h"
  42 #include "psb_pvr_glue.h"
  43
  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);
  48
  49 static const struct drm_framebuffer_funcs psb_fb_funcs = {
  50         .destroy = psb_user_framebuffer_destroy,
  51         .create_handle = psb_user_framebuffer_create_handle,
  52 };
  53
  54 #define CMAP_TOHW(_val, _width) ((((_val) << (_width)) + 0x7FFF - (_val)) >> 16)
  55
  56 void *psbfb_vdc_reg(struct drm_device *dev)
  57 {
  58         struct drm_psb_private *dev_priv;
  59         dev_priv = (struct drm_psb_private *) dev->dev_private;
  60         return dev_priv->vdc_reg;
  61 }
  62 /*EXPORT_SYMBOL(psbfb_vdc_reg); */
  63
  64 static int psbfb_setcolreg(unsigned regno, unsigned red, unsigned green,
  65                            unsigned blue, unsigned transp,
  66                            struct fb_info *info)
  67 {
  68         struct psb_fbdev *fbdev = info->par;
  69         struct drm_framebuffer *fb = fbdev->psb_fb_helper.fb;
  70         uint32_t v;
  71
  72         if (!fb)
  73                 return -ENOMEM;
  74
  75         if (regno > 255)
  76                 return 1;
  77
  78         red = CMAP_TOHW(red, info->var.red.length);
  79         blue = CMAP_TOHW(blue, info->var.blue.length);
  80         green = CMAP_TOHW(green, info->var.green.length);
  81         transp = CMAP_TOHW(transp, info->var.transp.length);
  82
  83         v = (red << info->var.red.offset) |
  84             (green << info->var.green.offset) |
  85             (blue << info->var.blue.offset) |
  86             (transp << info->var.transp.offset);
  87
  88         if (regno < 16) {
  89                 switch (fb->bits_per_pixel) {
  90                 case 16:
  91                         ((uint32_t *) info->pseudo_palette)[regno] = v;
  92                         break;
  93                 case 24:
  94                 case 32:
  95                         ((uint32_t *) info->pseudo_palette)[regno] = v;
  96                         break;
  97                 }
  98         }
  99
 100         return 0;
 101 }
 102
 103 static int psbfb_kms_off(struct drm_device *dev, int suspend)
 104 {
 105         struct drm_framebuffer *fb = 0;
 106         struct psb_framebuffer *psbfb = to_psb_fb(fb);
 107         DRM_DEBUG("psbfb_kms_off_ioctl\n");
 108
 109         mutex_lock(&dev->mode_config.mutex);
 110         list_for_each_entry(fb, &dev->mode_config.fb_list, head) {
 111                 struct fb_info *info = psbfb->fbdev;
 112
 113                 if (suspend) {
 114                         fb_set_suspend(info, 1);
 115                         drm_fb_helper_blank(FB_BLANK_POWERDOWN, info);
 116                 }
 117         }
 118         mutex_unlock(&dev->mode_config.mutex);
 119         return 0;
 120 }
 121
 122 int psbfb_kms_off_ioctl(struct drm_device *dev, void *data,
 123                         struct drm_file *file_priv)
 124 {
 125         int ret;
 126
 127         if (drm_psb_no_fb)
 128                 return 0;
 129         console_lock();
 130         ret = psbfb_kms_off(dev, 0);
 131         console_unlock();
 132
 133         return ret;
 134 }
 135
 136 static int psbfb_kms_on(struct drm_device *dev, int resume)
 137 {
 138         struct drm_framebuffer *fb = 0;
 139         struct psb_framebuffer *psbfb = to_psb_fb(fb);
 140
 141         DRM_DEBUG("psbfb_kms_on_ioctl\n");
 142
 143         mutex_lock(&dev->mode_config.mutex);
 144         list_for_each_entry(fb, &dev->mode_config.fb_list, head) {
 145                 struct fb_info *info = psbfb->fbdev;
 146
 147                 if (resume) {
 148                         fb_set_suspend(info, 0);
 149                         drm_fb_helper_blank(FB_BLANK_UNBLANK, info);
 150                 }
 151         }
 152         mutex_unlock(&dev->mode_config.mutex);
 153
 154         return 0;
 155 }
 156
 157 int psbfb_kms_on_ioctl(struct drm_device *dev, void *data,
 158                        struct drm_file *file_priv)
 159 {
 160         int ret;
 161
 162         if (drm_psb_no_fb)
 163                 return 0;
 164         console_lock();
 165         ret = psbfb_kms_on(dev, 0);
 166         console_unlock();
 167         drm_helper_disable_unused_functions(dev);
 168         return ret;
 169 }
 170
 171 void psbfb_suspend(struct drm_device *dev)
 172 {
 173         console_lock();
 174         psbfb_kms_off(dev, 1);
 175         console_unlock();
 176 }
 177
 178 void psbfb_resume(struct drm_device *dev)
 179 {
 180         console_lock();
 181         psbfb_kms_on(dev, 1);
 182         console_unlock();
 183         drm_helper_disable_unused_functions(dev);
 184 }
 185
 186 static int psbfb_vm_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
 187 {
 188         int page_num = 0;
 189         int i;
 190         unsigned long address = 0;
 191         int ret;
 192         unsigned long pfn;
 193         struct psb_framebuffer *psbfb = vma->vm_private_data;
 194         struct drm_device *dev = psbfb->base.dev;
 195         struct drm_psb_private *dev_priv = dev->dev_private;
 196         struct psb_gtt *pg = dev_priv->pg;
 197         unsigned long phys_addr = (unsigned long)pg->stolen_base;;
 198
 199         page_num = (vma->vm_end - vma->vm_start) >> PAGE_SHIFT;
 200
 201         address = (unsigned long)vmf->virtual_address;
 202
 203         vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
 204
 205         for (i = 0; i < page_num; i++) {
 206                 pfn = (phys_addr >> PAGE_SHIFT); /* phys_to_pfn(phys_addr); */
 207
 208                 ret = vm_insert_mixed(vma, address, pfn);
 209                 if (unlikely((ret == -EBUSY) || (ret != 0 && i > 0)))
 210                         break;
 211                 else if (unlikely(ret != 0)) {
 212                         ret = (ret == -ENOMEM) ? VM_FAULT_OOM : VM_FAULT_SIGBUS;
 213                         return ret;
 214                 }
 215
 216                 address += PAGE_SIZE;
 217                 phys_addr += PAGE_SIZE;
 218         }
 219
 220         return VM_FAULT_NOPAGE;
 221 }
 222
 223 static void psbfb_vm_open(struct vm_area_struct *vma)
 224 {
 225         DRM_DEBUG("vm_open\n");
 226 }
 227
 228 static void psbfb_vm_close(struct vm_area_struct *vma)
 229 {
 230         DRM_DEBUG("vm_close\n");
 231 }
 232
 233 static struct vm_operations_struct psbfb_vm_ops = {
 234         .fault  = psbfb_vm_fault,
 235         .open   = psbfb_vm_open,
 236         .close  = psbfb_vm_close
 237 };
 238
 239 static int psbfb_mmap(struct fb_info *info, struct vm_area_struct *vma)
 240 {
 241         struct psb_fbdev *fbdev = info->par;
 242         struct psb_framebuffer *psbfb = fbdev->pfb;
 243         char *fb_screen_base = NULL;
 244         struct drm_device *dev = psbfb->base.dev;
 245         struct drm_psb_private *dev_priv = dev->dev_private;
 246         struct psb_gtt *pg = dev_priv->pg;
 247
 248         if (vma->vm_pgoff != 0)
 249                 return -EINVAL;
 250         if (vma->vm_pgoff > (~0UL >> PAGE_SHIFT))
 251                 return -EINVAL;
 252
 253         if (!psbfb->addr_space)
 254                 psbfb->addr_space = vma->vm_file->f_mapping;
 255
 256         fb_screen_base = (char *)info->screen_base;
 257
 258         DRM_DEBUG("vm_pgoff 0x%lx, screen base %p vram_addr %p\n",
 259                                 vma->vm_pgoff, fb_screen_base, pg->vram_addr);
 260
 261         /*if using stolen memory, */
 262         if (fb_screen_base == pg->vram_addr) {
 263                 vma->vm_ops = &psbfb_vm_ops;
 264                 vma->vm_private_data = (void *)psbfb;
 265                 vma->vm_flags |= VM_RESERVED | VM_IO |
 266                                                 VM_MIXEDMAP | VM_DONTEXPAND;
 267         } else {
 268         /*using IMG meminfo, can I use pvrmmap to map it?*/
 269
 270         }
 271
 272         return 0;
 273 }
 274
 275
 276 static struct fb_ops psbfb_ops = {
 277         .owner = THIS_MODULE,
 278         .fb_check_var = drm_fb_helper_check_var,
 279         .fb_set_par = drm_fb_helper_set_par,
 280         .fb_blank = drm_fb_helper_blank,
 281         .fb_setcolreg = psbfb_setcolreg,
 282         .fb_fillrect = psbfb_fillrect,
 283         .fb_copyarea = psbfb_copyarea,
 284         .fb_imageblit = psbfb_imageblit,
 285         .fb_mmap = psbfb_mmap,
 286         .fb_sync = psbfb_sync,
 287 };
 288
 289 static struct drm_framebuffer *psb_framebuffer_create
 290                         (struct drm_device *dev, struct drm_mode_fb_cmd *r,
 291                          void *mm_private)
 292 {
 293         struct psb_framebuffer *fb;
 294         int ret;
 295
 296         fb = kzalloc(sizeof(*fb), GFP_KERNEL);
 297         if (!fb)
 298                 return NULL;
 299
 300         ret = drm_framebuffer_init(dev, &fb->base, &psb_fb_funcs);
 301
 302         if (ret)
 303                 goto err;
 304
 305         drm_helper_mode_fill_fb_struct(&fb->base, r);
 306
 307         fb->bo = mm_private;
 308
 309         return &fb->base;
 310
 311 err:
 312         kfree(fb);
 313         return NULL;
 314 }
 315
 316 static struct drm_framebuffer *psb_user_framebuffer_create
 317                         (struct drm_device *dev, struct drm_file *filp,
 318                          struct drm_mode_fb_cmd *r)
 319 {
 320         struct ttm_buffer_object *bo = NULL;
 321         uint64_t size;
 322
 323         bo = ttm_buffer_object_lookup(psb_fpriv(filp)->tfile, r->handle);
 324         if (!bo)
 325                 return NULL;
 326
 327         /* JB: TODO not drop, make smarter */
 328         size = ((uint64_t) bo->num_pages) << PAGE_SHIFT;
 329         if (size < r->width * r->height * 4)
 330                 return NULL;
 331
 332         /* JB: TODO not drop, refcount buffer */
 333         return psb_framebuffer_create(dev, r, bo);
 334
 335 #if 0
 336         struct psb_framebuffer *psbfb;
 337         struct drm_framebuffer *fb;
 338         struct fb_info *info;
 339         void *psKernelMemInfo = NULL;
 340         void * hKernelMemInfo = (void *)r->handle;
 341         struct drm_psb_private *dev_priv
 342                 = (struct drm_psb_private *)dev->dev_private;
 343         struct psb_fbdev *fbdev = dev_priv->fbdev;
 344         struct psb_gtt *pg = dev_priv->pg;
 345         int ret;
 346         uint32_t offset;
 347         uint64_t size;
 348
 349         ret = psb_get_meminfo_by_handle(hKernelMemInfo, &psKernelMemInfo);
 350         if (ret) {
 351                 DRM_ERROR("Cannot get meminfo for handle 0x%x\n",
 352                                                 (u32)hKernelMemInfo);
 353                 return NULL;
 354         }
 355
 356         DRM_DEBUG("Got Kernel MemInfo for handle %lx\n",
 357                   (u32)hKernelMemInfo);
 358
 359         /* JB: TODO not drop, make smarter */
 360         size = psKernelMemInfo->ui32AllocSize;
 361         if (size < r->height * r->pitch)
 362                 return NULL;
 363
 364         /* JB: TODO not drop, refcount buffer */
 365         /* return psb_framebuffer_create(dev, r, bo); */
 366
 367         fb = psb_framebuffer_create(dev, r, (void *)psKernelMemInfo);
 368         if (!fb) {
 369                 DRM_ERROR("failed to allocate fb.\n");
 370                 return NULL;
 371         }
 372
 373         psbfb = to_psb_fb(fb);
 374         psbfb->size = size;
 375         psbfb->hKernelMemInfo = hKernelMemInfo;
 376
 377         DRM_DEBUG("Mapping to gtt..., KernelMemInfo %p\n", psKernelMemInfo);
 378
 379         /*if not VRAM, map it into tt aperture*/
 380         if (psKernelMemInfo->pvLinAddrKM != pg->vram_addr) {
 381                 ret = psb_gtt_map_meminfo(dev, hKernelMemInfo, &offset);
 382                 if (ret) {
 383                         DRM_ERROR("map meminfo for 0x%x failed\n",
 384                                   (u32)hKernelMemInfo);
 385                         return NULL;
 386                 }
 387                 psbfb->offset = (offset << PAGE_SHIFT);
 388         } else {
 389                 psbfb->offset = 0;
 390         }
 391         info = framebuffer_alloc(0, &dev->pdev->dev);
 392         if (!info)
 393                 return NULL;
 394
 395         strcpy(info->fix.id, "psbfb");
 396
 397         info->flags = FBINFO_DEFAULT;
 398         info->fix.accel = FB_ACCEL_I830;        /*FIXMEAC*/
 399         info->fbops = &psbfb_ops;
 400
 401         info->fix.smem_start = dev->mode_config.fb_base;
 402         info->fix.smem_len = size;
 403
 404         info->screen_base = psKernelMemInfo->pvLinAddrKM;
 405         info->screen_size = size;
 406
 407         drm_fb_helper_fill_fix(info, fb->pitch, fb->depth);
 408         drm_fb_helper_fill_var(info, &fbdev->psb_fb_helper,
 409                                                         fb->width, fb->height);
 410
 411         info->fix.mmio_start = pci_resource_start(dev->pdev, 0);
 412         info->fix.mmio_len = pci_resource_len(dev->pdev, 0);
 413
 414         info->pixmap.size = 64 * 1024;
 415         info->pixmap.buf_align = 8;
 416         info->pixmap.access_align = 32;
 417         info->pixmap.flags = FB_PIXMAP_SYSTEM;
 418         info->pixmap.scan_align = 1;
 419
 420         psbfb->fbdev = info;
 421         fbdev->pfb = psbfb;
 422
 423         fbdev->psb_fb_helper.fb = fb;
 424         fbdev->psb_fb_helper.fbdev = info;
 425         MRSTLFBHandleChangeFB(dev, psbfb);
 426
 427         return fb;
 428 #endif
 429 }
 430
 431 static int psbfb_create(struct psb_fbdev *fbdev,
 432                                 struct drm_fb_helper_surface_size *sizes)
 433 {
 434         struct drm_device *dev = fbdev->psb_fb_helper.dev;
 435         struct drm_psb_private *dev_priv = dev->dev_private;
 436         struct psb_gtt *pg = dev_priv->pg;
 437         struct fb_info *info;
 438         struct drm_framebuffer *fb;
 439         struct psb_framebuffer *psbfb;
 440         struct drm_mode_fb_cmd mode_cmd;
 441         struct device *device = &dev->pdev->dev;
 442
 443         struct ttm_buffer_object *fbo = NULL;
 444         int size, aligned_size;
 445         int ret;
 446
 447         mode_cmd.width = sizes->surface_width;
 448         mode_cmd.height = sizes->surface_height;
 449
 450         mode_cmd.bpp = 32;
 451         /* HW requires pitch to be 64 byte aligned */
 452         mode_cmd.pitch =  ALIGN(mode_cmd.width * ((mode_cmd.bpp + 1) / 8), 64);
 453         mode_cmd.depth = 24;
 454
 455         size = mode_cmd.pitch * mode_cmd.height;
 456         aligned_size = ALIGN(size, PAGE_SIZE);
 457
 458         mutex_lock(&dev->struct_mutex);
 459         fb = psb_framebuffer_create(dev, &mode_cmd, fbo);
 460         if (!fb) {
 461                 DRM_ERROR("failed to allocate fb.\n");
 462                 ret = -ENOMEM;
 463                 goto out_err1;
 464         }
 465         psbfb = to_psb_fb(fb);
 466         psbfb->size = size;
 467
 468         info = framebuffer_alloc(sizeof(struct psb_fbdev), device);
 469         if (!info) {
 470                 ret = -ENOMEM;
 471                 goto out_err0;
 472         }
 473
 474         info->par = fbdev;
 475
 476         psbfb->fbdev = info;
 477
 478         fbdev->psb_fb_helper.fb = fb;
 479         fbdev->psb_fb_helper.fbdev = info;
 480         fbdev->pfb = psbfb;
 481
 482         strcpy(info->fix.id, "psbfb");
 483
 484         info->flags = FBINFO_DEFAULT;
 485         info->fbops = &psbfb_ops;
 486         info->fix.smem_start = dev->mode_config.fb_base;
 487         info->fix.smem_len = size;
 488         info->screen_base = (char *)pg->vram_addr;
 489         info->screen_size = size;
 490         memset(info->screen_base, 0, size);
 491
 492         if (dev_priv->pg->stolen_size) {
 493                 info->apertures = alloc_apertures(1);
 494                 if (!info->apertures) {
 495                         ret = -ENOMEM;
 496                         goto out_err0;
 497                 }
 498                 info->apertures->ranges[0].base = dev->mode_config.fb_base;
 499                 info->apertures->ranges[0].size = dev_priv->pg->stolen_size;
 500         }
 501
 502         drm_fb_helper_fill_fix(info, fb->pitch, fb->depth);
 503         drm_fb_helper_fill_var(info, &fbdev->psb_fb_helper,
 504                                 sizes->fb_width, sizes->fb_height);
 505
 506         info->fix.mmio_start = pci_resource_start(dev->pdev, 0);
 507         info->fix.mmio_len = pci_resource_len(dev->pdev, 0);
 508
 509         info->pixmap.size = 64 * 1024;
 510         info->pixmap.buf_align = 8;
 511         info->pixmap.access_align = 32;
 512         info->pixmap.flags = FB_PIXMAP_SYSTEM;
 513         info->pixmap.scan_align = 1;
 514
 515         DRM_DEBUG("fb depth is %d\n", fb->depth);
 516         DRM_DEBUG("   pitch is %d\n", fb->pitch);
 517
 518         printk(KERN_INFO"allocated %dx%d fb\n",
 519                                 psbfb->base.width, psbfb->base.height);
 520
 521         mutex_unlock(&dev->struct_mutex);
 522
 523         return 0;
 524 out_err0:
 525         fb->funcs->destroy(fb);
 526 out_err1:
 527         mutex_unlock(&dev->struct_mutex);
 528         return ret;
 529 }
 530
 531 static void psbfb_gamma_set(struct drm_crtc *crtc, u16 red, u16 green,
 532                                                         u16 blue, int regno)
 533 {
 534         DRM_DEBUG("%s\n", __func__);
 535 }
 536
 537 static void psbfb_gamma_get(struct drm_crtc *crtc, u16 *red,
 538                                         u16 *green, u16 *blue, int regno)
 539 {
 540         DRM_DEBUG("%s\n", __func__);
 541 }
 542
 543 static int psbfb_probe(struct drm_fb_helper *helper,
 544                                 struct drm_fb_helper_surface_size *sizes)
 545 {
 546         struct psb_fbdev *psb_fbdev = (struct psb_fbdev *)helper;
 547         int new_fb = 0;
 548         int ret;
 549
 550         DRM_DEBUG("%s\n", __func__);
 551
 552         if (!helper->fb) {
 553                 ret = psbfb_create(psb_fbdev, sizes);
 554                 if (ret)
 555                         return ret;
 556                 new_fb = 1;
 557         }
 558         return new_fb;
 559 }
 560
 561 struct drm_fb_helper_funcs psb_fb_helper_funcs = {
 562         .gamma_set = psbfb_gamma_set,
 563         .gamma_get = psbfb_gamma_get,
 564         .fb_probe = psbfb_probe,
 565 };
 566
 567 int psb_fbdev_destroy(struct drm_device *dev, struct psb_fbdev *fbdev)
 568 {
 569         struct fb_info *info;
 570         struct psb_framebuffer *psbfb = fbdev->pfb;
 571
 572         if (fbdev->psb_fb_helper.fbdev) {
 573                 info = fbdev->psb_fb_helper.fbdev;
 574                 unregister_framebuffer(info);
 575                 iounmap(info->screen_base);
 576                 framebuffer_release(info);
 577         }
 578
 579         drm_fb_helper_fini(&fbdev->psb_fb_helper);
 580
 581         drm_framebuffer_cleanup(&psbfb->base);
 582
 583         return 0;
 584 }
 585
 586 int psb_fbdev_init(struct drm_device *dev)
 587 {
 588         struct psb_fbdev *fbdev;
 589         struct drm_psb_private *dev_priv = dev->dev_private;
 590         int num_crtc;
 591
 592         fbdev = kzalloc(sizeof(struct psb_fbdev), GFP_KERNEL);
 593         if (!fbdev) {
 594                 DRM_ERROR("no memory\n");
 595                 return -ENOMEM;
 596         }
 597
 598         dev_priv->fbdev = fbdev;
 599         fbdev->psb_fb_helper.funcs = &psb_fb_helper_funcs;
 600
 601         num_crtc = 2;
 602
 603         drm_fb_helper_init(dev, &fbdev->psb_fb_helper, num_crtc,
 604                                                         INTELFB_CONN_LIMIT);
 605
 606         drm_fb_helper_single_add_all_connectors(&fbdev->psb_fb_helper);
 607         drm_fb_helper_initial_config(&fbdev->psb_fb_helper, 32);
 608         return 0;
 609 }
 610
 611 void psb_fbdev_fini(struct drm_device *dev)
 612 {
 613         struct drm_psb_private *dev_priv = dev->dev_private;
 614
 615         if (!dev_priv->fbdev)
 616                 return;
 617
 618         psb_fbdev_destroy(dev, dev_priv->fbdev);
 619         kfree(dev_priv->fbdev);
 620         dev_priv->fbdev = NULL;
 621 }
 622
 623
 624 static void psbfb_output_poll_changed(struct drm_device *dev)
 625 {
 626         struct drm_psb_private *dev_priv = dev->dev_private;
 627         struct psb_fbdev *fbdev = (struct psb_fbdev *)dev_priv->fbdev;
 628         drm_fb_helper_hotplug_event(&fbdev->psb_fb_helper);
 629 }
 630
 631 int psbfb_remove(struct drm_device *dev, struct drm_framebuffer *fb)
 632 {
 633         struct fb_info *info;
 634         struct psb_framebuffer *psbfb = to_psb_fb(fb);
 635
 636         if (drm_psb_no_fb)
 637                 return 0;
 638
 639         info = psbfb->fbdev;
 640         psbfb->pvrBO = NULL;
 641
 642         if (info)
 643                 framebuffer_release(info);
 644         return 0;
 645 }
 646 /*EXPORT_SYMBOL(psbfb_remove); */
 647
 648 static int psb_user_framebuffer_create_handle(struct drm_framebuffer *fb,
 649                                               struct drm_file *file_priv,
 650                                               unsigned int *handle)
 651 {
 652         /* JB: TODO currently we can't go from a bo to a handle with ttm */
 653         (void) file_priv;
 654         *handle = 0;
 655         return 0;
 656 }
 657
 658 static void psb_user_framebuffer_destroy(struct drm_framebuffer *fb)
 659 {
 660         struct drm_device *dev = fb->dev;
 661         struct psb_framebuffer *psbfb = to_psb_fb(fb);
 662
 663         /*ummap gtt pages*/
 664         psb_gtt_unmap_meminfo(dev, psbfb->hKernelMemInfo);
 665         if (psbfb->fbdev)
 666                 psbfb_remove(dev, fb);
 667
 668         /* JB: TODO not drop, refcount buffer */
 669         drm_framebuffer_cleanup(fb);
 670         kfree(fb);
 671 }
 672
 673 static const struct drm_mode_config_funcs psb_mode_funcs = {
 674         .fb_create = psb_user_framebuffer_create,
 675         .output_poll_changed = psbfb_output_poll_changed,
 676 };
 677
 678 static int psb_create_backlight_property(struct drm_device *dev)
 679 {
 680         struct drm_psb_private *dev_priv
 681                                 = (struct drm_psb_private *) dev->dev_private;
 682         struct drm_property *backlight;
 683
 684         if (dev_priv->backlight_property)
 685                 return 0;
 686
 687         backlight = drm_property_create(dev,
 688                                         DRM_MODE_PROP_RANGE,
 689                                         "backlight",
 690                                         2);
 691         backlight->values[0] = 0;
 692         backlight->values[1] = 100;
 693
 694         dev_priv->backlight_property = backlight;
 695
 696         return 0;
 697 }
 698
 699 static void psb_setup_outputs(struct drm_device *dev)
 700 {
 701         struct drm_psb_private *dev_priv =
 702             (struct drm_psb_private *) dev->dev_private;
 703         struct drm_connector *connector;
 704
 705         PSB_DEBUG_ENTRY("\n");
 706
 707         drm_mode_create_scaling_mode_property(dev);
 708
 709         psb_create_backlight_property(dev);
 710
 711         psb_intel_lvds_init(dev, &dev_priv->mode_dev);
 712         /* psb_intel_sdvo_init(dev, SDVOB); */
 713
 714         list_for_each_entry(connector, &dev->mode_config.connector_list,
 715                             head) {
 716                 struct psb_intel_output *psb_intel_output =
 717                     to_psb_intel_output(connector);
 718                 struct drm_encoder *encoder = &psb_intel_output->enc;
 719                 int crtc_mask = 0, clone_mask = 0;
 720
 721                 /* valid crtcs */
 722                 switch (psb_intel_output->type) {
 723                 case INTEL_OUTPUT_SDVO:
 724                         crtc_mask = ((1 << 0) | (1 << 1));
 725                         clone_mask = (1 << INTEL_OUTPUT_SDVO);
 726                         break;
 727                 case INTEL_OUTPUT_LVDS:
 728                         PSB_DEBUG_ENTRY("LVDS.\n");
 729                         crtc_mask = (1 << 1);
 730                         clone_mask = (1 << INTEL_OUTPUT_LVDS);
 731                         break;
 732                 case INTEL_OUTPUT_MIPI:
 733                         PSB_DEBUG_ENTRY("MIPI.\n");
 734                         crtc_mask = (1 << 0);
 735                         clone_mask = (1 << INTEL_OUTPUT_MIPI);
 736                         break;
 737                 case INTEL_OUTPUT_MIPI2:
 738                         PSB_DEBUG_ENTRY("MIPI2.\n");
 739                         crtc_mask = (1 << 2);
 740                         clone_mask = (1 << INTEL_OUTPUT_MIPI2);
 741                         break;
 742                 case INTEL_OUTPUT_HDMI:
 743                         PSB_DEBUG_ENTRY("HDMI.\n");
 744                         crtc_mask = (1 << 1);
 745                         clone_mask = (1 << INTEL_OUTPUT_HDMI);
 746                         break;
 747                 }
 748
 749                 encoder->possible_crtcs = crtc_mask;
 750                 encoder->possible_clones =
 751                     psb_intel_connector_clones(dev, clone_mask);
 752
 753         }
 754 }
 755
 756 static void *psb_bo_from_handle(struct drm_device *dev,
 757                                 struct drm_file *file_priv,
 758                                 unsigned int handle)
 759 {
 760         void *psKernelMemInfo = NULL;
 761         void * hKernelMemInfo = (void *)handle;
 762         int ret;
 763
 764         ret = psb_get_meminfo_by_handle(hKernelMemInfo, &psKernelMemInfo);
 765         if (ret) {
 766                 DRM_ERROR("Cannot get meminfo for handle 0x%x\n",
 767                           (u32)hKernelMemInfo);
 768                 return NULL;
 769         }
 770
 771         return (void *)psKernelMemInfo;
 772 }
 773
 774 static size_t psb_bo_size(struct drm_device *dev, void *bof)
 775 {
 776 #if 0
 777         void *psKernelMemInfo   = (void *)bof;
 778         return (size_t)psKernelMemInfo->ui32AllocSize;
 779 #else
 780         return 0;
 781 #endif
 782 }
 783
 784 static size_t psb_bo_offset(struct drm_device *dev, void *bof)
 785 {
 786         struct psb_framebuffer *psbfb
 787                 = (struct psb_framebuffer *)bof;
 788
 789         return (size_t)psbfb->offset;
 790 }
 791
 792 static int psb_bo_pin_for_scanout(struct drm_device *dev, void *bo)
 793 {
 794          return 0;
 795 }
 796
 797 static int psb_bo_unpin_for_scanout(struct drm_device *dev, void *bo)
 798 {
 799         return 0;
 800 }
 801
 802 void psb_modeset_init(struct drm_device *dev)
 803 {
 804         struct drm_psb_private *dev_priv =
 805             (struct drm_psb_private *) dev->dev_private;
 806         struct psb_intel_mode_device *mode_dev = &dev_priv->mode_dev;
 807         int i;
 808
 809         PSB_DEBUG_ENTRY("\n");
 810         /* Init mm functions */
 811         mode_dev->bo_from_handle = psb_bo_from_handle;
 812         mode_dev->bo_size = psb_bo_size;
 813         mode_dev->bo_offset = psb_bo_offset;
 814         mode_dev->bo_pin_for_scanout = psb_bo_pin_for_scanout;
 815         mode_dev->bo_unpin_for_scanout = psb_bo_unpin_for_scanout;
 816
 817         drm_mode_config_init(dev);
 818
 819         dev->mode_config.min_width = 0;
 820         dev->mode_config.min_height = 0;
 821
 822         dev->mode_config.funcs = (void *) &psb_mode_funcs;
 823
 824         /* set memory base */
 825         /* MRST and PSB should use BAR 2*/
 826         pci_read_config_dword(dev->pdev, PSB_BSM, (u32 *)
 827                                         &(dev->mode_config.fb_base));
 828
 829         /* num pipes is 2 for PSB but 1 for Mrst */
 830         for (i = 0; i < dev_priv->num_pipe; i++)
 831                 psb_intel_crtc_init(dev, i, mode_dev);
 832
 833         dev->mode_config.max_width = 2048;
 834         dev->mode_config.max_height = 2048;
 835
 836         psb_setup_outputs(dev);
 837
 838         /* setup fbs */
 839         /* drm_initial_config(dev); */
 840 }
 841
 842 void psb_modeset_cleanup(struct drm_device *dev)
 843 {
 844         mutex_lock(&dev->struct_mutex);
 845
 846         drm_kms_helper_poll_fini(dev);
 847         psb_fbdev_fini(dev);
 848
 849         drm_mode_config_cleanup(dev);
 850
 851         mutex_unlock(&dev->struct_mutex);
 852 }