Commit | Line | Data |
---|---|---|
a080db9f CH |
1 | /* |
2 | * Copyright 2013 Matrox Graphics | |
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 | * Author: Christopher Harvey <charvey@matrox.com> | |
9 | */ | |
10 | ||
11 | #include <drm/drmP.h> | |
12 | #include "mgag200_drv.h" | |
13 | ||
14 | static bool warn_transparent = true; | |
15 | static bool warn_palette = true; | |
16 | ||
17 | /* | |
18 | Hide the cursor off screen. We can't disable the cursor hardware because it | |
19 | takes too long to re-activate and causes momentary corruption | |
20 | */ | |
21 | static void mga_hide_cursor(struct mga_device *mdev) | |
22 | { | |
23 | WREG8(MGA_CURPOSXL, 0); | |
24 | WREG8(MGA_CURPOSXH, 0); | |
25 | mgag200_bo_unpin(mdev->cursor.pixels_1); | |
26 | mgag200_bo_unpin(mdev->cursor.pixels_2); | |
27 | } | |
28 | ||
29 | int mga_crtc_cursor_set(struct drm_crtc *crtc, | |
30 | struct drm_file *file_priv, | |
31 | uint32_t handle, | |
32 | uint32_t width, | |
33 | uint32_t height) | |
34 | { | |
35 | struct drm_device *dev = (struct drm_device *)file_priv->minor->dev; | |
36 | struct mga_device *mdev = (struct mga_device *)dev->dev_private; | |
37 | struct mgag200_bo *pixels_1 = mdev->cursor.pixels_1; | |
38 | struct mgag200_bo *pixels_2 = mdev->cursor.pixels_2; | |
39 | struct mgag200_bo *pixels_current = mdev->cursor.pixels_current; | |
40 | struct mgag200_bo *pixels_prev = mdev->cursor.pixels_prev; | |
41 | struct drm_gem_object *obj; | |
42 | struct mgag200_bo *bo = NULL; | |
43 | int ret = 0; | |
44 | unsigned int i, row, col; | |
45 | uint32_t colour_set[16]; | |
46 | uint32_t *next_space = &colour_set[0]; | |
47 | uint32_t *palette_iter; | |
48 | uint32_t this_colour; | |
49 | bool found = false; | |
50 | int colour_count = 0; | |
51 | u64 gpu_addr; | |
52 | u8 reg_index; | |
53 | u8 this_row[48]; | |
54 | ||
55 | if (!pixels_1 || !pixels_2) { | |
56 | WREG8(MGA_CURPOSXL, 0); | |
57 | WREG8(MGA_CURPOSXH, 0); | |
58 | return -ENOTSUPP; /* Didn't allocate space for cursors */ | |
59 | } | |
60 | ||
61 | if ((width != 64 || height != 64) && handle) { | |
62 | WREG8(MGA_CURPOSXL, 0); | |
63 | WREG8(MGA_CURPOSXH, 0); | |
64 | return -EINVAL; | |
65 | } | |
66 | ||
67 | BUG_ON(pixels_1 != pixels_current && pixels_1 != pixels_prev); | |
68 | BUG_ON(pixels_2 != pixels_current && pixels_2 != pixels_prev); | |
69 | BUG_ON(pixels_current == pixels_prev); | |
70 | ||
71 | ret = mgag200_bo_reserve(pixels_1, true); | |
72 | if (ret) { | |
73 | WREG8(MGA_CURPOSXL, 0); | |
74 | WREG8(MGA_CURPOSXH, 0); | |
75 | return ret; | |
76 | } | |
77 | ret = mgag200_bo_reserve(pixels_2, true); | |
78 | if (ret) { | |
79 | WREG8(MGA_CURPOSXL, 0); | |
80 | WREG8(MGA_CURPOSXH, 0); | |
81 | mgag200_bo_unreserve(pixels_1); | |
82 | return ret; | |
83 | } | |
84 | ||
85 | if (!handle) { | |
86 | mga_hide_cursor(mdev); | |
87 | ret = 0; | |
88 | goto out1; | |
89 | } | |
90 | ||
91 | /* Move cursor buffers into VRAM if they aren't already */ | |
92 | if (!pixels_1->pin_count) { | |
93 | ret = mgag200_bo_pin(pixels_1, TTM_PL_FLAG_VRAM, | |
94 | &mdev->cursor.pixels_1_gpu_addr); | |
95 | if (ret) | |
96 | goto out1; | |
97 | } | |
98 | if (!pixels_2->pin_count) { | |
99 | ret = mgag200_bo_pin(pixels_2, TTM_PL_FLAG_VRAM, | |
100 | &mdev->cursor.pixels_2_gpu_addr); | |
101 | if (ret) { | |
102 | mgag200_bo_unpin(pixels_1); | |
103 | goto out1; | |
104 | } | |
105 | } | |
106 | ||
107 | mutex_lock(&dev->struct_mutex); | |
108 | obj = drm_gem_object_lookup(dev, file_priv, handle); | |
109 | if (!obj) { | |
110 | mutex_unlock(&dev->struct_mutex); | |
111 | ret = -ENOENT; | |
112 | goto out1; | |
113 | } | |
114 | drm_gem_object_unreference(obj); | |
115 | mutex_unlock(&dev->struct_mutex); | |
116 | ||
117 | bo = gem_to_mga_bo(obj); | |
118 | ret = mgag200_bo_reserve(bo, true); | |
119 | if (ret) { | |
120 | dev_err(&dev->pdev->dev, "failed to reserve user bo\n"); | |
121 | goto out1; | |
122 | } | |
123 | if (!bo->kmap.virtual) { | |
124 | ret = ttm_bo_kmap(&bo->bo, 0, bo->bo.num_pages, &bo->kmap); | |
125 | if (ret) { | |
126 | dev_err(&dev->pdev->dev, "failed to kmap user buffer updates\n"); | |
127 | goto out2; | |
128 | } | |
129 | } | |
130 | ||
131 | memset(&colour_set[0], 0, sizeof(uint32_t)*16); | |
132 | /* width*height*4 = 16384 */ | |
133 | for (i = 0; i < 16384; i += 4) { | |
134 | this_colour = ioread32(bo->kmap.virtual + i); | |
135 | /* No transparency */ | |
136 | if (this_colour>>24 != 0xff && | |
137 | this_colour>>24 != 0x0) { | |
138 | if (warn_transparent) { | |
139 | dev_info(&dev->pdev->dev, "Video card doesn't support cursors with partial transparency.\n"); | |
140 | dev_info(&dev->pdev->dev, "Not enabling hardware cursor.\n"); | |
141 | warn_transparent = false; /* Only tell the user once. */ | |
142 | } | |
143 | ret = -EINVAL; | |
144 | goto out3; | |
145 | } | |
146 | /* Don't need to store transparent pixels as colours */ | |
147 | if (this_colour>>24 == 0x0) | |
148 | continue; | |
149 | found = false; | |
150 | for (palette_iter = &colour_set[0]; palette_iter != next_space; palette_iter++) { | |
151 | if (*palette_iter == this_colour) { | |
152 | found = true; | |
153 | break; | |
154 | } | |
155 | } | |
156 | if (found) | |
157 | continue; | |
158 | /* We only support 4bit paletted cursors */ | |
159 | if (colour_count >= 16) { | |
160 | if (warn_palette) { | |
161 | dev_info(&dev->pdev->dev, "Video card only supports cursors with up to 16 colours.\n"); | |
162 | dev_info(&dev->pdev->dev, "Not enabling hardware cursor.\n"); | |
163 | warn_palette = false; /* Only tell the user once. */ | |
164 | } | |
165 | ret = -EINVAL; | |
166 | goto out3; | |
167 | } | |
168 | *next_space = this_colour; | |
169 | next_space++; | |
170 | colour_count++; | |
171 | } | |
172 | ||
173 | /* Program colours from cursor icon into palette */ | |
174 | for (i = 0; i < colour_count; i++) { | |
175 | if (i <= 2) | |
176 | reg_index = 0x8 + i*0x4; | |
177 | else | |
178 | reg_index = 0x60 + i*0x3; | |
179 | WREG_DAC(reg_index, colour_set[i] & 0xff); | |
180 | WREG_DAC(reg_index+1, colour_set[i]>>8 & 0xff); | |
181 | WREG_DAC(reg_index+2, colour_set[i]>>16 & 0xff); | |
182 | BUG_ON((colour_set[i]>>24 & 0xff) != 0xff); | |
183 | } | |
184 | ||
185 | /* Map up-coming buffer to write colour indices */ | |
186 | if (!pixels_prev->kmap.virtual) { | |
187 | ret = ttm_bo_kmap(&pixels_prev->bo, 0, | |
188 | pixels_prev->bo.num_pages, | |
189 | &pixels_prev->kmap); | |
190 | if (ret) { | |
191 | dev_err(&dev->pdev->dev, "failed to kmap cursor updates\n"); | |
192 | goto out3; | |
193 | } | |
194 | } | |
195 | ||
196 | /* now write colour indices into hardware cursor buffer */ | |
197 | for (row = 0; row < 64; row++) { | |
198 | memset(&this_row[0], 0, 48); | |
199 | for (col = 0; col < 64; col++) { | |
200 | this_colour = ioread32(bo->kmap.virtual + 4*(col + 64*row)); | |
201 | /* write transparent pixels */ | |
202 | if (this_colour>>24 == 0x0) { | |
203 | this_row[47 - col/8] |= 0x80>>(col%8); | |
204 | continue; | |
205 | } | |
206 | ||
207 | /* write colour index here */ | |
208 | for (i = 0; i < colour_count; i++) { | |
209 | if (colour_set[i] == this_colour) { | |
210 | if (col % 2) | |
211 | this_row[col/2] |= i<<4; | |
212 | else | |
213 | this_row[col/2] |= i; | |
214 | break; | |
215 | } | |
216 | } | |
217 | } | |
218 | memcpy_toio(pixels_prev->kmap.virtual + row*48, &this_row[0], 48); | |
219 | } | |
220 | ||
221 | /* Program gpu address of cursor buffer */ | |
222 | if (pixels_prev == pixels_1) | |
223 | gpu_addr = mdev->cursor.pixels_1_gpu_addr; | |
224 | else | |
225 | gpu_addr = mdev->cursor.pixels_2_gpu_addr; | |
226 | WREG_DAC(MGA1064_CURSOR_BASE_ADR_LOW, (u8)((gpu_addr>>10) & 0xff)); | |
227 | WREG_DAC(MGA1064_CURSOR_BASE_ADR_HI, (u8)((gpu_addr>>18) & 0x3f)); | |
228 | ||
229 | /* Adjust cursor control register to turn on the cursor */ | |
230 | WREG_DAC(MGA1064_CURSOR_CTL, 4); /* 16-colour palletized cursor mode */ | |
231 | ||
232 | /* Now swap internal buffer pointers */ | |
233 | if (mdev->cursor.pixels_1 == mdev->cursor.pixels_prev) { | |
234 | mdev->cursor.pixels_prev = mdev->cursor.pixels_2; | |
235 | mdev->cursor.pixels_current = mdev->cursor.pixels_1; | |
236 | } else if (mdev->cursor.pixels_1 == mdev->cursor.pixels_current) { | |
237 | mdev->cursor.pixels_prev = mdev->cursor.pixels_1; | |
238 | mdev->cursor.pixels_current = mdev->cursor.pixels_2; | |
239 | } else { | |
240 | BUG(); | |
241 | } | |
242 | ret = 0; | |
243 | ||
244 | ttm_bo_kunmap(&pixels_prev->kmap); | |
245 | out3: | |
246 | ttm_bo_kunmap(&bo->kmap); | |
247 | out2: | |
248 | mgag200_bo_unreserve(bo); | |
249 | out1: | |
250 | if (ret) | |
251 | mga_hide_cursor(mdev); | |
252 | mgag200_bo_unreserve(pixels_1); | |
253 | mgag200_bo_unreserve(pixels_2); | |
254 | return ret; | |
255 | } | |
256 | ||
257 | int mga_crtc_cursor_move(struct drm_crtc *crtc, int x, int y) | |
258 | { | |
259 | struct mga_device *mdev = (struct mga_device *)crtc->dev->dev_private; | |
260 | /* Our origin is at (64,64) */ | |
261 | x += 64; | |
262 | y += 64; | |
263 | ||
264 | BUG_ON(x <= 0); | |
265 | BUG_ON(y <= 0); | |
266 | BUG_ON(x & ~0xffff); | |
267 | BUG_ON(y & ~0xffff); | |
268 | ||
269 | WREG8(MGA_CURPOSXL, x & 0xff); | |
270 | WREG8(MGA_CURPOSXH, (x>>8) & 0xff); | |
271 | ||
272 | WREG8(MGA_CURPOSYL, y & 0xff); | |
273 | WREG8(MGA_CURPOSYH, (y>>8) & 0xff); | |
274 | return 0; | |
275 | } |