1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23#include <linux/module.h>
24#include <linux/kernel.h>
25#include <linux/errno.h>
26#include <linux/string.h>
27#include <linux/mm.h>
28#include <linux/tty.h>
29#include <linux/slab.h>
30#include <linux/delay.h>
31#include <linux/init.h>
32#include <linux/console.h>
33
34#include <drm/drmP.h>
35#include <drm/drm.h>
36#include <drm/drm_crtc.h>
37
38#include "psb_drv.h"
39#include "psb_reg.h"
40#include "framebuffer.h"
41
42
43
44
45
46
47
48
49
50void psb_spank(struct drm_psb_private *dev_priv)
51{
52 PSB_WSGX32(_PSB_CS_RESET_BIF_RESET | _PSB_CS_RESET_DPM_RESET |
53 _PSB_CS_RESET_TA_RESET | _PSB_CS_RESET_USE_RESET |
54 _PSB_CS_RESET_ISP_RESET | _PSB_CS_RESET_TSP_RESET |
55 _PSB_CS_RESET_TWOD_RESET, PSB_CR_SOFT_RESET);
56 PSB_RSGX32(PSB_CR_SOFT_RESET);
57
58 msleep(1);
59
60 PSB_WSGX32(0, PSB_CR_SOFT_RESET);
61 wmb();
62 PSB_WSGX32(PSB_RSGX32(PSB_CR_BIF_CTRL) | _PSB_CB_CTRL_CLEAR_FAULT,
63 PSB_CR_BIF_CTRL);
64 wmb();
65 (void) PSB_RSGX32(PSB_CR_BIF_CTRL);
66
67 msleep(1);
68 PSB_WSGX32(PSB_RSGX32(PSB_CR_BIF_CTRL) & ~_PSB_CB_CTRL_CLEAR_FAULT,
69 PSB_CR_BIF_CTRL);
70 (void) PSB_RSGX32(PSB_CR_BIF_CTRL);
71 PSB_WSGX32(dev_priv->gtt.gatt_start, PSB_CR_BIF_TWOD_REQ_BASE);
72}
73
74
75
76
77
78
79
80
81
82static int psb_2d_wait_available(struct drm_psb_private *dev_priv,
83 unsigned size)
84{
85 uint32_t avail = PSB_RSGX32(PSB_CR_2D_SOCIF);
86 unsigned long t = jiffies + HZ;
87
88 while (avail < size) {
89 avail = PSB_RSGX32(PSB_CR_2D_SOCIF);
90 if (time_after(jiffies, t)) {
91 psb_spank(dev_priv);
92 return -EIO;
93 }
94 }
95 return 0;
96}
97
98
99
100
101
102
103
104
105
106
107static int psbfb_2d_submit(struct drm_psb_private *dev_priv, uint32_t *cmdbuf,
108 unsigned size)
109{
110 int ret = 0;
111 int i;
112 unsigned submit_size;
113 unsigned long flags;
114
115 spin_lock_irqsave(&dev_priv->lock_2d, flags);
116 while (size > 0) {
117 submit_size = (size < 0x60) ? size : 0x60;
118 size -= submit_size;
119 ret = psb_2d_wait_available(dev_priv, submit_size);
120 if (ret)
121 break;
122
123 submit_size <<= 2;
124
125 for (i = 0; i < submit_size; i += 4)
126 PSB_WSGX32(*cmdbuf++, PSB_SGX_2D_SLAVE_PORT + i);
127
128 (void)PSB_RSGX32(PSB_SGX_2D_SLAVE_PORT + i - 4);
129 }
130 spin_unlock_irqrestore(&dev_priv->lock_2d, flags);
131 return ret;
132}
133
134
135
136
137
138
139
140
141
142
143static u32 psb_accel_2d_copy_direction(int xdir, int ydir)
144{
145 if (xdir < 0)
146 return (ydir < 0) ? PSB_2D_COPYORDER_BR2TL :
147 PSB_2D_COPYORDER_TR2BL;
148 else
149 return (ydir < 0) ? PSB_2D_COPYORDER_BL2TR :
150 PSB_2D_COPYORDER_TL2BR;
151}
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171static int psb_accel_2d_copy(struct drm_psb_private *dev_priv,
172 uint32_t src_offset, uint32_t src_stride,
173 uint32_t src_format, uint32_t dst_offset,
174 uint32_t dst_stride, uint32_t dst_format,
175 uint16_t src_x, uint16_t src_y,
176 uint16_t dst_x, uint16_t dst_y,
177 uint16_t size_x, uint16_t size_y)
178{
179 uint32_t blit_cmd;
180 uint32_t buffer[10];
181 uint32_t *buf;
182 uint32_t direction;
183
184 buf = buffer;
185
186 direction =
187 psb_accel_2d_copy_direction(src_x - dst_x, src_y - dst_y);
188
189 if (direction == PSB_2D_COPYORDER_BR2TL ||
190 direction == PSB_2D_COPYORDER_TR2BL) {
191 src_x += size_x - 1;
192 dst_x += size_x - 1;
193 }
194 if (direction == PSB_2D_COPYORDER_BR2TL ||
195 direction == PSB_2D_COPYORDER_BL2TR) {
196 src_y += size_y - 1;
197 dst_y += size_y - 1;
198 }
199
200 blit_cmd =
201 PSB_2D_BLIT_BH |
202 PSB_2D_ROT_NONE |
203 PSB_2D_DSTCK_DISABLE |
204 PSB_2D_SRCCK_DISABLE |
205 PSB_2D_USE_PAT | PSB_2D_ROP3_SRCCOPY | direction;
206
207 *buf++ = PSB_2D_FENCE_BH;
208 *buf++ =
209 PSB_2D_DST_SURF_BH | dst_format | (dst_stride <<
210 PSB_2D_DST_STRIDE_SHIFT);
211 *buf++ = dst_offset;
212 *buf++ =
213 PSB_2D_SRC_SURF_BH | src_format | (src_stride <<
214 PSB_2D_SRC_STRIDE_SHIFT);
215 *buf++ = src_offset;
216 *buf++ =
217 PSB_2D_SRC_OFF_BH | (src_x << PSB_2D_SRCOFF_XSTART_SHIFT) |
218 (src_y << PSB_2D_SRCOFF_YSTART_SHIFT);
219 *buf++ = blit_cmd;
220 *buf++ =
221 (dst_x << PSB_2D_DST_XSTART_SHIFT) | (dst_y <<
222 PSB_2D_DST_YSTART_SHIFT);
223 *buf++ =
224 (size_x << PSB_2D_DST_XSIZE_SHIFT) | (size_y <<
225 PSB_2D_DST_YSIZE_SHIFT);
226 *buf++ = PSB_2D_FLUSH_BH;
227
228 return psbfb_2d_submit(dev_priv, buffer, buf - buffer);
229}
230
231
232
233
234
235
236
237
238static void psbfb_copyarea_accel(struct fb_info *info,
239 const struct fb_copyarea *a)
240{
241 struct psb_fbdev *fbdev = info->par;
242 struct psb_framebuffer *psbfb = &fbdev->pfb;
243 struct drm_device *dev = psbfb->base.dev;
244 struct drm_framebuffer *fb = fbdev->psb_fb_helper.fb;
245 struct drm_psb_private *dev_priv = dev->dev_private;
246 uint32_t offset;
247 uint32_t stride;
248 uint32_t src_format;
249 uint32_t dst_format;
250
251 if (!fb)
252 return;
253
254 offset = psbfb->gtt->offset;
255 stride = fb->pitches[0];
256
257 switch (fb->format->depth) {
258 case 8:
259 src_format = PSB_2D_SRC_332RGB;
260 dst_format = PSB_2D_DST_332RGB;
261 break;
262 case 15:
263 src_format = PSB_2D_SRC_555RGB;
264 dst_format = PSB_2D_DST_555RGB;
265 break;
266 case 16:
267 src_format = PSB_2D_SRC_565RGB;
268 dst_format = PSB_2D_DST_565RGB;
269 break;
270 case 24:
271 case 32:
272
273 src_format = PSB_2D_SRC_8888ARGB;
274 dst_format = PSB_2D_DST_8888ARGB;
275 break;
276 default:
277
278 drm_fb_helper_cfb_copyarea(info, a);
279 return;
280 }
281
282 if (!gma_power_begin(dev, false)) {
283 drm_fb_helper_cfb_copyarea(info, a);
284 return;
285 }
286 psb_accel_2d_copy(dev_priv,
287 offset, stride, src_format,
288 offset, stride, dst_format,
289 a->sx, a->sy, a->dx, a->dy, a->width, a->height);
290 gma_power_end(dev);
291}
292
293
294
295
296
297
298
299
300
301void psbfb_copyarea(struct fb_info *info,
302 const struct fb_copyarea *region)
303{
304 if (unlikely(info->state != FBINFO_STATE_RUNNING))
305 return;
306
307
308 if (region->width == 8 || region->height == 8 ||
309 (info->flags & FBINFO_HWACCEL_DISABLED))
310 return drm_fb_helper_cfb_copyarea(info, region);
311
312 psbfb_copyarea_accel(info, region);
313}
314
315
316
317
318
319
320
321
322int psbfb_sync(struct fb_info *info)
323{
324 struct psb_fbdev *fbdev = info->par;
325 struct psb_framebuffer *psbfb = &fbdev->pfb;
326 struct drm_device *dev = psbfb->base.dev;
327 struct drm_psb_private *dev_priv = dev->dev_private;
328 unsigned long _end = jiffies + HZ;
329 int busy = 0;
330 unsigned long flags;
331
332 spin_lock_irqsave(&dev_priv->lock_2d, flags);
333
334
335
336
337 if ((PSB_RSGX32(PSB_CR_2D_SOCIF) == _PSB_C2_SOCIF_EMPTY) &&
338 ((PSB_RSGX32(PSB_CR_2D_BLIT_STATUS) & _PSB_C2B_STATUS_BUSY) == 0))
339 goto out;
340
341 do {
342 busy = (PSB_RSGX32(PSB_CR_2D_SOCIF) != _PSB_C2_SOCIF_EMPTY);
343 cpu_relax();
344 } while (busy && !time_after_eq(jiffies, _end));
345
346 if (busy)
347 busy = (PSB_RSGX32(PSB_CR_2D_SOCIF) != _PSB_C2_SOCIF_EMPTY);
348 if (busy)
349 goto out;
350
351 do {
352 busy = ((PSB_RSGX32(PSB_CR_2D_BLIT_STATUS) &
353 _PSB_C2B_STATUS_BUSY) != 0);
354 cpu_relax();
355 } while (busy && !time_after_eq(jiffies, _end));
356 if (busy)
357 busy = ((PSB_RSGX32(PSB_CR_2D_BLIT_STATUS) &
358 _PSB_C2B_STATUS_BUSY) != 0);
359
360out:
361 spin_unlock_irqrestore(&dev_priv->lock_2d, flags);
362 return (busy) ? -EBUSY : 0;
363}
364