aboutsummaryrefslogtreecommitdiffstats
path: root/drivers
diff options
context:
space:
mode:
authorGerd Hoffmann <kraxel@redhat.com>2019-05-22 06:33:07 -0400
committerGerd Hoffmann <kraxel@redhat.com>2019-05-23 06:16:01 -0400
commit0388f2f61befe1de58b3e6319b133ea9391812c1 (patch)
treeb883c07d482781ec196e83b3a0d622ddcc063a41 /drivers
parent3b1d715dc2edda1efa590fdf7cf9731501d4a44f (diff)
drm/cirrus: remove leftover files
cirrus_drv.h and cirrus_ttm.c are unused since commit ab3e023b1b4c ("drm/cirrus: rewrite and modernize driver"), apparently I ran "rm" instead of "git rm" on them so they are still in present the tree. Signed-off-by: Gerd Hoffmann <kraxel@redhat.com> Reviewed-by: Sam Ravnborg <sam@ravnborg.org> Link: http://patchwork.freedesktop.org/patch/msgid/20190522103307.12711-1-kraxel@redhat.com
Diffstat (limited to 'drivers')
-rw-r--r--drivers/gpu/drm/cirrus/cirrus_drv.h250
-rw-r--r--drivers/gpu/drm/cirrus/cirrus_ttm.c337
2 files changed, 0 insertions, 587 deletions
diff --git a/drivers/gpu/drm/cirrus/cirrus_drv.h b/drivers/gpu/drm/cirrus/cirrus_drv.h
deleted file mode 100644
index 1bd816be3aae..000000000000
--- a/drivers/gpu/drm/cirrus/cirrus_drv.h
+++ /dev/null
@@ -1,250 +0,0 @@
1/*
2 * Copyright 2012 Red Hat
3 *
4 * This file is subject to the terms and conditions of the GNU General
5 * Public License version 2. See the file COPYING in the main
6 * directory of this archive for more details.
7 *
8 * Authors: Matthew Garrett
9 * Dave Airlie
10 */
11#ifndef __CIRRUS_DRV_H__
12#define __CIRRUS_DRV_H__
13
14#include <video/vga.h>
15
16#include <drm/drm_encoder.h>
17#include <drm/drm_fb_helper.h>
18
19#include <drm/ttm/ttm_bo_api.h>
20#include <drm/ttm/ttm_bo_driver.h>
21#include <drm/ttm/ttm_placement.h>
22#include <drm/ttm/ttm_memory.h>
23#include <drm/ttm/ttm_module.h>
24
25#include <drm/drm_gem.h>
26
27#define DRIVER_AUTHOR "Matthew Garrett"
28
29#define DRIVER_NAME "cirrus"
30#define DRIVER_DESC "qemu Cirrus emulation"
31#define DRIVER_DATE "20110418"
32
33#define DRIVER_MAJOR 1
34#define DRIVER_MINOR 0
35#define DRIVER_PATCHLEVEL 0
36
37#define CIRRUSFB_CONN_LIMIT 1
38
39#define RREG8(reg) ioread8(((void __iomem *)cdev->rmmio) + (reg))
40#define WREG8(reg, v) iowrite8(v, ((void __iomem *)cdev->rmmio) + (reg))
41#define RREG32(reg) ioread32(((void __iomem *)cdev->rmmio) + (reg))
42#define WREG32(reg, v) iowrite32(v, ((void __iomem *)cdev->rmmio) + (reg))
43
44#define SEQ_INDEX 4
45#define SEQ_DATA 5
46
47#define WREG_SEQ(reg, v) \
48 do { \
49 WREG8(SEQ_INDEX, reg); \
50 WREG8(SEQ_DATA, v); \
51 } while (0) \
52
53#define CRT_INDEX 0x14
54#define CRT_DATA 0x15
55
56#define WREG_CRT(reg, v) \
57 do { \
58 WREG8(CRT_INDEX, reg); \
59 WREG8(CRT_DATA, v); \
60 } while (0) \
61
62#define GFX_INDEX 0xe
63#define GFX_DATA 0xf
64
65#define WREG_GFX(reg, v) \
66 do { \
67 WREG8(GFX_INDEX, reg); \
68 WREG8(GFX_DATA, v); \
69 } while (0) \
70
71/*
72 * Cirrus has a "hidden" DAC register that can be accessed by writing to
73 * the pixel mask register to reset the state, then reading from the register
74 * four times. The next write will then pass to the DAC
75 */
76#define VGA_DAC_MASK 0x6
77
78#define WREG_HDR(v) \
79 do { \
80 RREG8(VGA_DAC_MASK); \
81 RREG8(VGA_DAC_MASK); \
82 RREG8(VGA_DAC_MASK); \
83 RREG8(VGA_DAC_MASK); \
84 WREG8(VGA_DAC_MASK, v); \
85 } while (0) \
86
87
88#define CIRRUS_MAX_FB_HEIGHT 4096
89#define CIRRUS_MAX_FB_WIDTH 4096
90
91#define CIRRUS_DPMS_CLEARED (-1)
92
93#define to_cirrus_crtc(x) container_of(x, struct cirrus_crtc, base)
94#define to_cirrus_encoder(x) container_of(x, struct cirrus_encoder, base)
95
96struct cirrus_crtc {
97 struct drm_crtc base;
98 int last_dpms;
99 bool enabled;
100};
101
102struct cirrus_fbdev;
103struct cirrus_mode_info {
104 struct cirrus_crtc *crtc;
105 /* pointer to fbdev info structure */
106 struct cirrus_fbdev *gfbdev;
107};
108
109struct cirrus_encoder {
110 struct drm_encoder base;
111 int last_dpms;
112};
113
114struct cirrus_connector {
115 struct drm_connector base;
116};
117
118struct cirrus_mc {
119 resource_size_t vram_size;
120 resource_size_t vram_base;
121};
122
123struct cirrus_device {
124 struct drm_device *dev;
125 unsigned long flags;
126
127 resource_size_t rmmio_base;
128 resource_size_t rmmio_size;
129 void __iomem *rmmio;
130
131 struct cirrus_mc mc;
132 struct cirrus_mode_info mode_info;
133
134 int num_crtc;
135 int fb_mtrr;
136
137 struct {
138 struct ttm_bo_device bdev;
139 } ttm;
140 bool mm_inited;
141};
142
143
144struct cirrus_fbdev {
145 struct drm_fb_helper helper; /* must be first */
146 struct drm_framebuffer *gfb;
147 void *sysram;
148 int size;
149 int x1, y1, x2, y2; /* dirty rect */
150 spinlock_t dirty_lock;
151};
152
153struct cirrus_bo {
154 struct ttm_buffer_object bo;
155 struct ttm_placement placement;
156 struct ttm_bo_kmap_obj kmap;
157 struct drm_gem_object gem;
158 struct ttm_place placements[3];
159 int pin_count;
160};
161#define gem_to_cirrus_bo(gobj) container_of((gobj), struct cirrus_bo, gem)
162
163static inline struct cirrus_bo *
164cirrus_bo(struct ttm_buffer_object *bo)
165{
166 return container_of(bo, struct cirrus_bo, bo);
167}
168
169
170#define to_cirrus_obj(x) container_of(x, struct cirrus_gem_object, base)
171
172 /* cirrus_main.c */
173int cirrus_device_init(struct cirrus_device *cdev,
174 struct drm_device *ddev,
175 struct pci_dev *pdev,
176 uint32_t flags);
177void cirrus_device_fini(struct cirrus_device *cdev);
178void cirrus_gem_free_object(struct drm_gem_object *obj);
179int cirrus_dumb_mmap_offset(struct drm_file *file,
180 struct drm_device *dev,
181 uint32_t handle,
182 uint64_t *offset);
183int cirrus_gem_create(struct drm_device *dev,
184 u32 size, bool iskernel,
185 struct drm_gem_object **obj);
186int cirrus_dumb_create(struct drm_file *file,
187 struct drm_device *dev,
188 struct drm_mode_create_dumb *args);
189
190int cirrus_framebuffer_init(struct drm_device *dev,
191 struct drm_framebuffer *gfb,
192 const struct drm_mode_fb_cmd2 *mode_cmd,
193 struct drm_gem_object *obj);
194
195bool cirrus_check_framebuffer(struct cirrus_device *cdev, int width, int height,
196 int bpp, int pitch);
197
198 /* cirrus_display.c */
199int cirrus_modeset_init(struct cirrus_device *cdev);
200void cirrus_modeset_fini(struct cirrus_device *cdev);
201
202 /* cirrus_fbdev.c */
203int cirrus_fbdev_init(struct cirrus_device *cdev);
204void cirrus_fbdev_fini(struct cirrus_device *cdev);
205
206
207
208 /* cirrus_irq.c */
209void cirrus_driver_irq_preinstall(struct drm_device *dev);
210int cirrus_driver_irq_postinstall(struct drm_device *dev);
211void cirrus_driver_irq_uninstall(struct drm_device *dev);
212irqreturn_t cirrus_driver_irq_handler(int irq, void *arg);
213
214 /* cirrus_kms.c */
215int cirrus_driver_load(struct drm_device *dev, unsigned long flags);
216void cirrus_driver_unload(struct drm_device *dev);
217extern struct drm_ioctl_desc cirrus_ioctls[];
218extern int cirrus_max_ioctl;
219
220int cirrus_mm_init(struct cirrus_device *cirrus);
221void cirrus_mm_fini(struct cirrus_device *cirrus);
222void cirrus_ttm_placement(struct cirrus_bo *bo, int domain);
223int cirrus_bo_create(struct drm_device *dev, int size, int align,
224 uint32_t flags, struct cirrus_bo **pcirrusbo);
225int cirrus_mmap(struct file *filp, struct vm_area_struct *vma);
226
227static inline int cirrus_bo_reserve(struct cirrus_bo *bo, bool no_wait)
228{
229 int ret;
230
231 ret = ttm_bo_reserve(&bo->bo, true, no_wait, NULL);
232 if (ret) {
233 if (ret != -ERESTARTSYS && ret != -EBUSY)
234 DRM_ERROR("reserve failed %p\n", bo);
235 return ret;
236 }
237 return 0;
238}
239
240static inline void cirrus_bo_unreserve(struct cirrus_bo *bo)
241{
242 ttm_bo_unreserve(&bo->bo);
243}
244
245int cirrus_bo_push_sysram(struct cirrus_bo *bo);
246int cirrus_bo_pin(struct cirrus_bo *bo, u32 pl_flag, u64 *gpu_addr);
247
248extern int cirrus_bpp;
249
250#endif /* __CIRRUS_DRV_H__ */
diff --git a/drivers/gpu/drm/cirrus/cirrus_ttm.c b/drivers/gpu/drm/cirrus/cirrus_ttm.c
deleted file mode 100644
index e6b98467a428..000000000000
--- a/drivers/gpu/drm/cirrus/cirrus_ttm.c
+++ /dev/null
@@ -1,337 +0,0 @@
1/*
2 * Copyright 2012 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
6 * "Software"), to deal in the Software without restriction, including
7 * without limitation the rights to use, copy, modify, merge, publish,
8 * distribute, sub license, and/or sell copies of the Software, and to
9 * permit persons to whom the Software is furnished to do so, subject to
10 * the following conditions:
11 *
12 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
13 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
14 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
15 * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
16 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
17 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
18 * USE OR OTHER DEALINGS IN THE SOFTWARE.
19 *
20 * The above copyright notice and this permission notice (including the
21 * next paragraph) shall be included in all copies or substantial portions
22 * of the Software.
23 *
24 */
25/*
26 * Authors: Dave Airlie <airlied@redhat.com>
27 */
28#include <drm/drmP.h>
29#include <drm/ttm/ttm_page_alloc.h>
30
31#include "cirrus_drv.h"
32
33static inline struct cirrus_device *
34cirrus_bdev(struct ttm_bo_device *bd)
35{
36 return container_of(bd, struct cirrus_device, ttm.bdev);
37}
38
39static void cirrus_bo_ttm_destroy(struct ttm_buffer_object *tbo)
40{
41 struct cirrus_bo *bo;
42
43 bo = container_of(tbo, struct cirrus_bo, bo);
44
45 drm_gem_object_release(&bo->gem);
46 kfree(bo);
47}
48
49static bool cirrus_ttm_bo_is_cirrus_bo(struct ttm_buffer_object *bo)
50{
51 if (bo->destroy == &cirrus_bo_ttm_destroy)
52 return true;
53 return false;
54}
55
56static int
57cirrus_bo_init_mem_type(struct ttm_bo_device *bdev, uint32_t type,
58 struct ttm_mem_type_manager *man)
59{
60 switch (type) {
61 case TTM_PL_SYSTEM:
62 man->flags = TTM_MEMTYPE_FLAG_MAPPABLE;
63 man->available_caching = TTM_PL_MASK_CACHING;
64 man->default_caching = TTM_PL_FLAG_CACHED;
65 break;
66 case TTM_PL_VRAM:
67 man->func = &ttm_bo_manager_func;
68 man->flags = TTM_MEMTYPE_FLAG_FIXED |
69 TTM_MEMTYPE_FLAG_MAPPABLE;
70 man->available_caching = TTM_PL_FLAG_UNCACHED |
71 TTM_PL_FLAG_WC;
72 man->default_caching = TTM_PL_FLAG_WC;
73 break;
74 default:
75 DRM_ERROR("Unsupported memory type %u\n", (unsigned)type);
76 return -EINVAL;
77 }
78 return 0;
79}
80
81static void
82cirrus_bo_evict_flags(struct ttm_buffer_object *bo, struct ttm_placement *pl)
83{
84 struct cirrus_bo *cirrusbo = cirrus_bo(bo);
85
86 if (!cirrus_ttm_bo_is_cirrus_bo(bo))
87 return;
88
89 cirrus_ttm_placement(cirrusbo, TTM_PL_FLAG_SYSTEM);
90 *pl = cirrusbo->placement;
91}
92
93static int cirrus_bo_verify_access(struct ttm_buffer_object *bo, struct file *filp)
94{
95 struct cirrus_bo *cirrusbo = cirrus_bo(bo);
96
97 return drm_vma_node_verify_access(&cirrusbo->gem.vma_node,
98 filp->private_data);
99}
100
101static int cirrus_ttm_io_mem_reserve(struct ttm_bo_device *bdev,
102 struct ttm_mem_reg *mem)
103{
104 struct ttm_mem_type_manager *man = &bdev->man[mem->mem_type];
105 struct cirrus_device *cirrus = cirrus_bdev(bdev);
106
107 mem->bus.addr = NULL;
108 mem->bus.offset = 0;
109 mem->bus.size = mem->num_pages << PAGE_SHIFT;
110 mem->bus.base = 0;
111 mem->bus.is_iomem = false;
112 if (!(man->flags & TTM_MEMTYPE_FLAG_MAPPABLE))
113 return -EINVAL;
114 switch (mem->mem_type) {
115 case TTM_PL_SYSTEM:
116 /* system memory */
117 return 0;
118 case TTM_PL_VRAM:
119 mem->bus.offset = mem->start << PAGE_SHIFT;
120 mem->bus.base = pci_resource_start(cirrus->dev->pdev, 0);
121 mem->bus.is_iomem = true;
122 break;
123 default:
124 return -EINVAL;
125 break;
126 }
127 return 0;
128}
129
130static void cirrus_ttm_io_mem_free(struct ttm_bo_device *bdev, struct ttm_mem_reg *mem)
131{
132}
133
134static void cirrus_ttm_backend_destroy(struct ttm_tt *tt)
135{
136 ttm_tt_fini(tt);
137 kfree(tt);
138}
139
140static struct ttm_backend_func cirrus_tt_backend_func = {
141 .destroy = &cirrus_ttm_backend_destroy,
142};
143
144
145static struct ttm_tt *cirrus_ttm_tt_create(struct ttm_buffer_object *bo,
146 uint32_t page_flags)
147{
148 struct ttm_tt *tt;
149
150 tt = kzalloc(sizeof(struct ttm_tt), GFP_KERNEL);
151 if (tt == NULL)
152 return NULL;
153 tt->func = &cirrus_tt_backend_func;
154 if (ttm_tt_init(tt, bo, page_flags)) {
155 kfree(tt);
156 return NULL;
157 }
158 return tt;
159}
160
161struct ttm_bo_driver cirrus_bo_driver = {
162 .ttm_tt_create = cirrus_ttm_tt_create,
163 .init_mem_type = cirrus_bo_init_mem_type,
164 .eviction_valuable = ttm_bo_eviction_valuable,
165 .evict_flags = cirrus_bo_evict_flags,
166 .move = NULL,
167 .verify_access = cirrus_bo_verify_access,
168 .io_mem_reserve = &cirrus_ttm_io_mem_reserve,
169 .io_mem_free = &cirrus_ttm_io_mem_free,
170};
171
172int cirrus_mm_init(struct cirrus_device *cirrus)
173{
174 int ret;
175 struct drm_device *dev = cirrus->dev;
176 struct ttm_bo_device *bdev = &cirrus->ttm.bdev;
177
178 ret = ttm_bo_device_init(&cirrus->ttm.bdev,
179 &cirrus_bo_driver,
180 dev->anon_inode->i_mapping,
181 true);
182 if (ret) {
183 DRM_ERROR("Error initialising bo driver; %d\n", ret);
184 return ret;
185 }
186
187 ret = ttm_bo_init_mm(bdev, TTM_PL_VRAM,
188 cirrus->mc.vram_size >> PAGE_SHIFT);
189 if (ret) {
190 DRM_ERROR("Failed ttm VRAM init: %d\n", ret);
191 return ret;
192 }
193
194 arch_io_reserve_memtype_wc(pci_resource_start(dev->pdev, 0),
195 pci_resource_len(dev->pdev, 0));
196
197 cirrus->fb_mtrr = arch_phys_wc_add(pci_resource_start(dev->pdev, 0),
198 pci_resource_len(dev->pdev, 0));
199
200 cirrus->mm_inited = true;
201 return 0;
202}
203
204void cirrus_mm_fini(struct cirrus_device *cirrus)
205{
206 struct drm_device *dev = cirrus->dev;
207
208 if (!cirrus->mm_inited)
209 return;
210
211 ttm_bo_device_release(&cirrus->ttm.bdev);
212
213 arch_phys_wc_del(cirrus->fb_mtrr);
214 cirrus->fb_mtrr = 0;
215 arch_io_free_memtype_wc(pci_resource_start(dev->pdev, 0),
216 pci_resource_len(dev->pdev, 0));
217}
218
219void cirrus_ttm_placement(struct cirrus_bo *bo, int domain)
220{
221 u32 c = 0;
222 unsigned i;
223 bo->placement.placement = bo->placements;
224 bo->placement.busy_placement = bo->placements;
225 if (domain & TTM_PL_FLAG_VRAM)
226 bo->placements[c++].flags = TTM_PL_FLAG_WC | TTM_PL_FLAG_UNCACHED | TTM_PL_FLAG_VRAM;
227 if (domain & TTM_PL_FLAG_SYSTEM)
228 bo->placements[c++].flags = TTM_PL_MASK_CACHING | TTM_PL_FLAG_SYSTEM;
229 if (!c)
230 bo->placements[c++].flags = TTM_PL_MASK_CACHING | TTM_PL_FLAG_SYSTEM;
231 bo->placement.num_placement = c;
232 bo->placement.num_busy_placement = c;
233 for (i = 0; i < c; ++i) {
234 bo->placements[i].fpfn = 0;
235 bo->placements[i].lpfn = 0;
236 }
237}
238
239int cirrus_bo_create(struct drm_device *dev, int size, int align,
240 uint32_t flags, struct cirrus_bo **pcirrusbo)
241{
242 struct cirrus_device *cirrus = dev->dev_private;
243 struct cirrus_bo *cirrusbo;
244 size_t acc_size;
245 int ret;
246
247 cirrusbo = kzalloc(sizeof(struct cirrus_bo), GFP_KERNEL);
248 if (!cirrusbo)
249 return -ENOMEM;
250
251 ret = drm_gem_object_init(dev, &cirrusbo->gem, size);
252 if (ret) {
253 kfree(cirrusbo);
254 return ret;
255 }
256
257 cirrusbo->bo.bdev = &cirrus->ttm.bdev;
258
259 cirrus_ttm_placement(cirrusbo, TTM_PL_FLAG_VRAM | TTM_PL_FLAG_SYSTEM);
260
261 acc_size = ttm_bo_dma_acc_size(&cirrus->ttm.bdev, size,
262 sizeof(struct cirrus_bo));
263
264 ret = ttm_bo_init(&cirrus->ttm.bdev, &cirrusbo->bo, size,
265 ttm_bo_type_device, &cirrusbo->placement,
266 align >> PAGE_SHIFT, false, acc_size,
267 NULL, NULL, cirrus_bo_ttm_destroy);
268 if (ret)
269 return ret;
270
271 *pcirrusbo = cirrusbo;
272 return 0;
273}
274
275static inline u64 cirrus_bo_gpu_offset(struct cirrus_bo *bo)
276{
277 return bo->bo.offset;
278}
279
280int cirrus_bo_pin(struct cirrus_bo *bo, u32 pl_flag, u64 *gpu_addr)
281{
282 struct ttm_operation_ctx ctx = { false, false };
283 int i, ret;
284
285 if (bo->pin_count) {
286 bo->pin_count++;
287 if (gpu_addr)
288 *gpu_addr = cirrus_bo_gpu_offset(bo);
289 }
290
291 cirrus_ttm_placement(bo, pl_flag);
292 for (i = 0; i < bo->placement.num_placement; i++)
293 bo->placements[i].flags |= TTM_PL_FLAG_NO_EVICT;
294 ret = ttm_bo_validate(&bo->bo, &bo->placement, &ctx);
295 if (ret)
296 return ret;
297
298 bo->pin_count = 1;
299 if (gpu_addr)
300 *gpu_addr = cirrus_bo_gpu_offset(bo);
301 return 0;
302}
303
304int cirrus_bo_push_sysram(struct cirrus_bo *bo)
305{
306 struct ttm_operation_ctx ctx = { false, false };
307 int i, ret;
308 if (!bo->pin_count) {
309 DRM_ERROR("unpin bad %p\n", bo);
310 return 0;
311 }
312 bo->pin_count--;
313 if (bo->pin_count)
314 return 0;
315
316 if (bo->kmap.virtual)
317 ttm_bo_kunmap(&bo->kmap);
318
319 cirrus_ttm_placement(bo, TTM_PL_FLAG_SYSTEM);
320 for (i = 0; i < bo->placement.num_placement ; i++)
321 bo->placements[i].flags |= TTM_PL_FLAG_NO_EVICT;
322
323 ret = ttm_bo_validate(&bo->bo, &bo->placement, &ctx);
324 if (ret) {
325 DRM_ERROR("pushing to VRAM failed\n");
326 return ret;
327 }
328 return 0;
329}
330
331int cirrus_mmap(struct file *filp, struct vm_area_struct *vma)
332{
333 struct drm_file *file_priv = filp->private_data;
334 struct cirrus_device *cirrus = file_priv->minor->dev->dev_private;
335
336 return ttm_bo_mmap(filp, vma, &cirrus->ttm.bdev);
337}
generated by cgit v1.2.2 (git 2.25.0) at 2025-08-30 17:00:08 -0400