Merge branch 'synaptics-rmi4' into next
[sfrench/cifs-2.6.git] / drivers / gpu / drm / drm_dma.c
1 /**
2  * \file drm_dma.c
3  * DMA IOCTL and function support
4  *
5  * \author Rickard E. (Rik) Faith <faith@valinux.com>
6  * \author Gareth Hughes <gareth@valinux.com>
7  */
8
9 /*
10  * Created: Fri Mar 19 14:30:16 1999 by faith@valinux.com
11  *
12  * Copyright 1999, 2000 Precision Insight, Inc., Cedar Park, Texas.
13  * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
14  * All Rights Reserved.
15  *
16  * Permission is hereby granted, free of charge, to any person obtaining a
17  * copy of this software and associated documentation files (the "Software"),
18  * to deal in the Software without restriction, including without limitation
19  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
20  * and/or sell copies of the Software, and to permit persons to whom the
21  * Software is furnished to do so, subject to the following conditions:
22  *
23  * The above copyright notice and this permission notice (including the next
24  * paragraph) shall be included in all copies or substantial portions of the
25  * Software.
26  *
27  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
28  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
29  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
30  * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
31  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
32  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
33  * OTHER DEALINGS IN THE SOFTWARE.
34  */
35
36 #include <linux/export.h>
37 #include <drm/drmP.h>
38 #include "drm_legacy.h"
39
40 /**
41  * Initialize the DMA data.
42  *
43  * \param dev DRM device.
44  * \return zero on success or a negative value on failure.
45  *
46  * Allocate and initialize a drm_device_dma structure.
47  */
48 int drm_legacy_dma_setup(struct drm_device *dev)
49 {
50         int i;
51
52         if (!drm_core_check_feature(dev, DRIVER_HAVE_DMA) ||
53             !drm_core_check_feature(dev, DRIVER_LEGACY))
54                 return 0;
55
56         dev->buf_use = 0;
57         atomic_set(&dev->buf_alloc, 0);
58
59         dev->dma = kzalloc(sizeof(*dev->dma), GFP_KERNEL);
60         if (!dev->dma)
61                 return -ENOMEM;
62
63         for (i = 0; i <= DRM_MAX_ORDER; i++)
64                 memset(&dev->dma->bufs[i], 0, sizeof(dev->dma->bufs[0]));
65
66         return 0;
67 }
68
69 /**
70  * Cleanup the DMA resources.
71  *
72  * \param dev DRM device.
73  *
74  * Free all pages associated with DMA buffers, the buffers and pages lists, and
75  * finally the drm_device::dma structure itself.
76  */
77 void drm_legacy_dma_takedown(struct drm_device *dev)
78 {
79         struct drm_device_dma *dma = dev->dma;
80         int i, j;
81
82         if (!drm_core_check_feature(dev, DRIVER_HAVE_DMA) ||
83             !drm_core_check_feature(dev, DRIVER_LEGACY))
84                 return;
85
86         if (!dma)
87                 return;
88
89         /* Clear dma buffers */
90         for (i = 0; i <= DRM_MAX_ORDER; i++) {
91                 if (dma->bufs[i].seg_count) {
92                         DRM_DEBUG("order %d: buf_count = %d,"
93                                   " seg_count = %d\n",
94                                   i,
95                                   dma->bufs[i].buf_count,
96                                   dma->bufs[i].seg_count);
97                         for (j = 0; j < dma->bufs[i].seg_count; j++) {
98                                 if (dma->bufs[i].seglist[j]) {
99                                         drm_pci_free(dev, dma->bufs[i].seglist[j]);
100                                 }
101                         }
102                         kfree(dma->bufs[i].seglist);
103                 }
104                 if (dma->bufs[i].buf_count) {
105                         for (j = 0; j < dma->bufs[i].buf_count; j++) {
106                                 kfree(dma->bufs[i].buflist[j].dev_private);
107                         }
108                         kfree(dma->bufs[i].buflist);
109                 }
110         }
111
112         kfree(dma->buflist);
113         kfree(dma->pagelist);
114         kfree(dev->dma);
115         dev->dma = NULL;
116 }
117
118 /**
119  * Free a buffer.
120  *
121  * \param dev DRM device.
122  * \param buf buffer to free.
123  *
124  * Resets the fields of \p buf.
125  */
126 void drm_legacy_free_buffer(struct drm_device *dev, struct drm_buf * buf)
127 {
128         if (!buf)
129                 return;
130
131         buf->waiting = 0;
132         buf->pending = 0;
133         buf->file_priv = NULL;
134         buf->used = 0;
135 }
136
137 /**
138  * Reclaim the buffers.
139  *
140  * \param file_priv DRM file private.
141  *
142  * Frees each buffer associated with \p file_priv not already on the hardware.
143  */
144 void drm_legacy_reclaim_buffers(struct drm_device *dev,
145                                 struct drm_file *file_priv)
146 {
147         struct drm_device_dma *dma = dev->dma;
148         int i;
149
150         if (!dma)
151                 return;
152         for (i = 0; i < dma->buf_count; i++) {
153                 if (dma->buflist[i]->file_priv == file_priv) {
154                         switch (dma->buflist[i]->list) {
155                         case DRM_LIST_NONE:
156                                 drm_legacy_free_buffer(dev, dma->buflist[i]);
157                                 break;
158                         case DRM_LIST_WAIT:
159                                 dma->buflist[i]->list = DRM_LIST_RECLAIM;
160                                 break;
161                         default:
162                                 /* Buffer already on hardware. */
163                                 break;
164                         }
165                 }
166         }
167 }