drivers/gpu/drm/nouveau/nvc0_fb.c

   1 /*
   2  * Copyright 2011 Red Hat Inc.
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice shall be included in
  12  * all copies or substantial portions of the Software.
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  17  * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
  18  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  19  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  20  * OTHER DEALINGS IN THE SOFTWARE.
  21  *
  22  * Authors: Ben Skeggs
  23  */
  24
  25 #include "drmP.h"
  26 #include "drm.h"
  27 #include "nouveau_drv.h"
  28 #include "nouveau_drm.h"
  29
  30 struct nvc0_fb_priv {
  31         struct page *r100c10_page;
  32         dma_addr_t r100c10;
  33 };
  34
  35 static void
  36 nvc0_fb_destroy(struct drm_device *dev)
  37 {
  38         struct drm_nouveau_private *dev_priv = dev->dev_private;
  39         struct nouveau_fb_engine *pfb = &dev_priv->engine.fb;
  40         struct nvc0_fb_priv *priv = pfb->priv;
  41
  42         if (priv->r100c10_page) {
  43                 pci_unmap_page(dev->pdev, priv->r100c10, PAGE_SIZE,
  44                                PCI_DMA_BIDIRECTIONAL);
  45                 __free_page(priv->r100c10_page);
  46         }
  47
  48         kfree(priv);
  49         pfb->priv = NULL;
  50 }
  51
  52 static int
  53 nvc0_fb_create(struct drm_device *dev)
  54 {
  55         struct drm_nouveau_private *dev_priv = dev->dev_private;
  56         struct nouveau_fb_engine *pfb = &dev_priv->engine.fb;
  57         struct nvc0_fb_priv *priv;
  58
  59         priv = kzalloc(sizeof(*priv), GFP_KERNEL);
  60         if (!priv)
  61                 return -ENOMEM;
  62         pfb->priv = priv;
  63
  64         priv->r100c10_page = alloc_page(GFP_KERNEL | __GFP_ZERO);
  65         if (!priv->r100c10_page) {
  66                 nvc0_fb_destroy(dev);
  67                 return -ENOMEM;
  68         }
  69
  70         priv->r100c10 = pci_map_page(dev->pdev, priv->r100c10_page, 0,
  71                                      PAGE_SIZE, PCI_DMA_BIDIRECTIONAL);
  72         if (pci_dma_mapping_error(dev->pdev, priv->r100c10)) {
  73                 nvc0_fb_destroy(dev);
  74                 return -EFAULT;
  75         }
  76
  77         return 0;
  78 }
  79
  80 int
  81 nvc0_fb_init(struct drm_device *dev)
  82 {
  83         struct drm_nouveau_private *dev_priv = dev->dev_private;
  84         struct nvc0_fb_priv *priv;
  85         int ret;
  86
  87         if (!dev_priv->engine.fb.priv) {
  88                 ret = nvc0_fb_create(dev);
  89                 if (ret)
  90                         return ret;
  91         }
  92         priv = dev_priv->engine.fb.priv;
  93
  94         nv_wr32(dev, 0x100c10, priv->r100c10 >> 8);
  95         return 0;
  96 }
  97
  98 void
  99 nvc0_fb_takedown(struct drm_device *dev)
 100 {
 101         nvc0_fb_destroy(dev);
 102 }