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 inline void
  36 nvc0_mfb_subp_isr(struct drm_device *dev, int unit, int subp)
  37 {
  38         u32 subp_base = 0x141000 + (unit * 0x2000) + (subp * 0x400);
  39         u32 stat = nv_rd32(dev, subp_base + 0x020);
  40
  41         if (stat) {
  42                 NV_INFO(dev, "PMFB%d_SUBP%d: 0x%08x\n", unit, subp, stat);
  43                 nv_wr32(dev, subp_base + 0x020, stat);
  44         }
  45 }
  46
  47 static void
  48 nvc0_mfb_isr(struct drm_device *dev)
  49 {
  50         u32 units = nv_rd32(dev, 0x00017c);
  51         while (units) {
  52                 u32 subp, unit = ffs(units) - 1;
  53                 for (subp = 0; subp < 2; subp++)
  54                         nvc0_mfb_subp_isr(dev, unit, subp);
  55                 units &= ~(1 << unit);
  56         }
  57 }
  58
  59 static void
  60 nvc0_fb_destroy(struct drm_device *dev)
  61 {
  62         struct drm_nouveau_private *dev_priv = dev->dev_private;
  63         struct nouveau_fb_engine *pfb = &dev_priv->engine.fb;
  64         struct nvc0_fb_priv *priv = pfb->priv;
  65
  66         nouveau_irq_unregister(dev, 25);
  67
  68         if (priv->r100c10_page) {
  69                 pci_unmap_page(dev->pdev, priv->r100c10, PAGE_SIZE,
  70                                PCI_DMA_BIDIRECTIONAL);
  71                 __free_page(priv->r100c10_page);
  72         }
  73
  74         kfree(priv);
  75         pfb->priv = NULL;
  76 }
  77
  78 static int
  79 nvc0_fb_create(struct drm_device *dev)
  80 {
  81         struct drm_nouveau_private *dev_priv = dev->dev_private;
  82         struct nouveau_fb_engine *pfb = &dev_priv->engine.fb;
  83         struct nvc0_fb_priv *priv;
  84
  85         priv = kzalloc(sizeof(*priv), GFP_KERNEL);
  86         if (!priv)
  87                 return -ENOMEM;
  88         pfb->priv = priv;
  89
  90         priv->r100c10_page = alloc_page(GFP_KERNEL | __GFP_ZERO);
  91         if (!priv->r100c10_page) {
  92                 nvc0_fb_destroy(dev);
  93                 return -ENOMEM;
  94         }
  95
  96         priv->r100c10 = pci_map_page(dev->pdev, priv->r100c10_page, 0,
  97                                      PAGE_SIZE, PCI_DMA_BIDIRECTIONAL);
  98         if (pci_dma_mapping_error(dev->pdev, priv->r100c10)) {
  99                 nvc0_fb_destroy(dev);
 100                 return -EFAULT;
 101         }
 102
 103         nouveau_irq_register(dev, 25, nvc0_mfb_isr);
 104         return 0;
 105 }
 106
 107 int
 108 nvc0_fb_init(struct drm_device *dev)
 109 {
 110         struct drm_nouveau_private *dev_priv = dev->dev_private;
 111         struct nvc0_fb_priv *priv;
 112         int ret;
 113
 114         if (!dev_priv->engine.fb.priv) {
 115                 ret = nvc0_fb_create(dev);
 116                 if (ret)
 117                         return ret;
 118         }
 119         priv = dev_priv->engine.fb.priv;
 120
 121         nv_wr32(dev, 0x100c10, priv->r100c10 >> 8);
 122         return 0;
 123 }
 124
 125 void
 126 nvc0_fb_takedown(struct drm_device *dev)
 127 {
 128         nvc0_fb_destroy(dev);
 129 }