Rev 6131 | Rev 6296 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
2340 | Serge | 1 | |
2 | |||
3 | |||
5060 | serge | 4 | #include |
5 | #include "i915_drv.h" |
||
2338 | Serge | 6 | #include "intel_drv.h" |
7 | #include |
||
8 | #include |
||
9 | #include |
||
10 | |||
11 | |||
12 | |||
13 | |||
6283 | serge | 14 | #include |
5354 | serge | 15 | |
2338 | Serge | 16 | |
6283 | serge | 17 | void kolibri_framebuffer_update(struct drm_i915_private *dev_priv, struct kos_framebuffer *kfb); |
18 | void init_system_cursors(struct drm_device *dev); |
||
19 | |||
2338 | Serge | 20 | |
6283 | serge | 21 | |
22 | |||
5354 | serge | 23 | |
2338 | Serge | 24 | |
5354 | serge | 25 | u32 cmd_offset; |
26 | |||
2340 | Serge | 27 | |
2351 | Serge | 28 | int sna_init(); |
29 | |||
30 | |||
3031 | serge | 31 | { |
32 | static char name[4]; |
||
33 | |||
34 | |||
35 | name[1] = ((x[0] & 0x03) << 3) + ((x[1] & 0xE0) >> 5) + '@'; |
||
36 | name[2] = (x[1] & 0x1F) + '@'; |
||
37 | name[3] = 0; |
||
38 | |||
39 | |||
40 | } |
||
41 | |||
42 | |||
6088 | serge | 43 | { |
44 | struct drm_display_mode *mode; |
||
45 | int count = 0; |
||
46 | |||
47 | |||
48 | count++; |
||
49 | |||
50 | |||
51 | }; |
||
52 | |||
53 | |||
6283 | serge | 54 | { |
55 | struct drm_i915_private *dev_priv = dev->dev_private; |
||
56 | struct intel_fbdev *ifbdev = dev_priv->fbdev; |
||
57 | struct intel_framebuffer *intel_fb = ifbdev->fb; |
||
58 | struct drm_framebuffer *fb = &intel_fb->base; |
||
59 | struct drm_i915_gem_object *obj = NULL; |
||
60 | int stride, size; |
||
61 | |||
62 | |||
63 | |||
64 | |||
65 | |||
66 | |||
67 | { |
||
68 | int gen3size; |
||
69 | |||
70 | |||
71 | for (stride = 512; stride < mode->hdisplay * 4; stride <<= 1); |
||
72 | else |
||
73 | stride = ALIGN(stride, 512); |
||
74 | size = stride * ALIGN(mode->vdisplay, 8); |
||
75 | |||
76 | |||
77 | { |
||
78 | for (gen3size = 1024*1024; gen3size < size; gen3size <<= 1); |
||
79 | size = gen3size; |
||
80 | } |
||
81 | else |
||
82 | size = ALIGN(size, 4096); |
||
83 | } |
||
84 | else |
||
85 | { |
||
86 | stride = ALIGN(stride, 64); |
||
87 | size = stride * ALIGN(mode->vdisplay, 2); |
||
88 | } |
||
89 | |||
90 | |||
91 | |||
92 | |||
93 | { |
||
94 | struct drm_mode_fb_cmd2 mode_cmd = {}; |
||
95 | int ret; |
||
96 | |||
97 | |||
98 | drm_framebuffer_remove(fb); |
||
99 | ifbdev->fb = NULL; |
||
100 | fb = NULL; |
||
101 | DRM_DEBUG_KMS("create new framebuffer\n"); |
||
102 | |||
103 | |||
104 | mode_cmd.height = mode->vdisplay; |
||
105 | |||
106 | |||
107 | mode_cmd.pixel_format = DRM_FORMAT_XRGB8888; |
||
108 | |||
109 | |||
110 | |||
111 | |||
112 | * important and we should probably use that space with FBC or other |
||
113 | * features. */ |
||
114 | if (size * 2 < dev_priv->gtt.stolen_usable_size) |
||
115 | obj = i915_gem_object_create_stolen(dev, size); |
||
116 | if (obj == NULL) |
||
117 | obj = i915_gem_alloc_object(dev, size); |
||
118 | if (!obj) { |
||
119 | DRM_ERROR("failed to allocate framebuffer\n"); |
||
120 | ret = -ENOMEM; |
||
121 | goto out; |
||
122 | } |
||
123 | |||
124 | |||
125 | if (IS_ERR(fb)) { |
||
126 | ret = PTR_ERR(fb); |
||
127 | goto out_unref; |
||
128 | } |
||
129 | |||
130 | |||
131 | ret = intel_pin_and_fence_fb_obj(NULL, fb, NULL, NULL, NULL); |
||
132 | if (ret) { |
||
133 | DRM_ERROR("failed to pin obj: %d\n", ret); |
||
134 | goto out_fb; |
||
135 | } |
||
136 | mutex_unlock(&dev->struct_mutex); |
||
137 | ifbdev->fb = to_intel_framebuffer(fb); |
||
138 | } |
||
139 | |||
140 | |||
141 | |||
142 | |||
143 | { |
||
144 | obj->tiling_mode = I915_TILING_X; |
||
145 | fb->modifier[0] = I915_FORMAT_MOD_X_TILED; |
||
146 | obj->fence_dirty = true; |
||
147 | obj->stride = stride; |
||
148 | }; |
||
149 | |||
150 | |||
151 | fb->height = mode->vdisplay; |
||
152 | |||
153 | |||
154 | fb->pitches[1] = |
||
155 | fb->pitches[2] = |
||
156 | fb->pitches[3] = stride; |
||
157 | |||
158 | |||
159 | fb->depth = 24; |
||
160 | LEAVE(); |
||
161 | return fb; |
||
162 | |||
163 | |||
164 | drm_framebuffer_remove(fb); |
||
165 | out_unref: |
||
166 | drm_gem_object_unreference(&obj->base); |
||
167 | out: |
||
168 | mutex_unlock(&dev->struct_mutex); |
||
169 | return NULL; |
||
170 | } |
||
171 | |||
172 | |||
5060 | serge | 173 | struct drm_crtc *crtc, videomode_t *reqmode, bool strict) |
174 | { |
||
3031 | serge | 175 | struct drm_i915_private *dev_priv = dev->dev_private; |
5060 | serge | 176 | struct drm_mode_config *config = &dev->mode_config; |
3031 | serge | 177 | struct drm_display_mode *mode = NULL, *tmpmode; |
178 | struct drm_connector *tmpc; |
||
6088 | serge | 179 | struct drm_framebuffer *fb = NULL; |
3031 | serge | 180 | struct drm_mode_set set; |
181 | char con_edid[128]; |
||
6283 | serge | 182 | int ret; |
3031 | serge | 183 | |
184 | |||
5060 | serge | 185 | |
3031 | serge | 186 | |
6088 | serge | 187 | { |
188 | const struct drm_connector_funcs *f = tmpc->funcs; |
||
189 | if(tmpc == connector) |
||
190 | continue; |
||
191 | f->dpms(tmpc, DRM_MODE_DPMS_OFF); |
||
192 | }; |
||
193 | |||
194 | |||
3031 | serge | 195 | { |
196 | if( (tmpmode->hdisplay == reqmode->width) && |
||
5060 | serge | 197 | (tmpmode->vdisplay == reqmode->height) && |
198 | (drm_mode_vrefresh(tmpmode) == reqmode->freq) ) |
||
3031 | serge | 199 | { |
200 | mode = tmpmode; |
||
201 | goto do_set; |
||
202 | } |
||
203 | }; |
||
204 | |||
205 | |||
206 | { |
||
207 | list_for_each_entry(tmpmode, &connector->modes, head) |
||
208 | { |
||
209 | if( (tmpmode->hdisplay == reqmode->width) && |
||
5060 | serge | 210 | (tmpmode->vdisplay == reqmode->height) ) |
211 | { |
||
3031 | serge | 212 | mode = tmpmode; |
213 | goto do_set; |
||
214 | } |
||
215 | }; |
||
216 | }; |
||
217 | |||
218 | |||
6283 | serge | 219 | drm_modeset_unlock_all(dev); |
220 | DRM_ERROR("%s failed\n", __FUNCTION__); |
||
3037 | serge | 221 | return -1; |
3031 | serge | 222 | |
223 | |||
224 | |||
225 | |||
6283 | serge | 226 | |
6088 | serge | 227 | |
6283 | serge | 228 | if(fb == NULL) |
229 | { |
||
230 | DRM_ERROR("%s failed\n", __FUNCTION__); |
||
231 | return -1; |
||
232 | }; |
||
233 | drm_framebuffer_reference(fb); |
||
234 | |||
3031 | serge | 235 | |
6283 | serge | 236 | |
6088 | serge | 237 | |
238 | |||
6283 | serge | 239 | |
240 | "monitor: %s model %x serial number %u\n", |
||
241 | mode->hdisplay, mode->vdisplay, |
||
242 | crtc->base.id, connector->name, |
||
243 | manufacturer_name(con_edid + 0x08), |
||
6088 | serge | 244 | (unsigned short)(con_edid[0x0A] + (con_edid[0x0B] << 8)), |
245 | (unsigned int)(con_edid[0x0C] + (con_edid[0x0D] << 8) |
||
246 | + (con_edid[0x0E] << 16) + (con_edid[0x0F] << 24))); |
||
247 | |||
248 | |||
3031 | serge | 249 | |
250 | |||
251 | os_display->crtc = crtc; |
||
252 | |||
253 | |||
6283 | serge | 254 | fb,fb->width,fb->height,fb->pitches[0],fb->pixel_format); |
6084 | serge | 255 | |
256 | |||
3031 | serge | 257 | set.x = 0; |
258 | set.y = 0; |
||
259 | set.mode = mode; |
||
260 | set.connectors = &connector; |
||
261 | set.num_connectors = 1; |
||
262 | set.fb = fb; |
||
263 | |||
264 | |||
5060 | serge | 265 | |
266 | |||
3031 | serge | 267 | { |
268 | struct intel_framebuffer *intel_fb = to_intel_framebuffer(fb); |
||
6283 | serge | 269 | struct kos_framebuffer *kfb = intel_fb->private; |
270 | kolibri_framebuffer_update(dev_priv, kfb); |
||
271 | DRM_DEBUG_KMS("kolibri framebuffer %p\n", kfb); |
||
272 | |||
273 | |||
274 | os_display->height = mode->vdisplay; |
||
275 | os_display->vrefresh = drm_mode_vrefresh(mode); |
||
3031 | serge | 276 | sysSetFramebuffer(intel_fb->private); |
6283 | serge | 277 | sysSetScreen(mode->hdisplay, mode->vdisplay, fb->pitches[0]); |
278 | |||
3031 | serge | 279 | |
6283 | serge | 280 | os_display->crtc = connector->encoder->crtc; |
281 | os_display->supported_modes = count_connector_modes(connector); |
||
282 | |||
3031 | serge | 283 | |
6283 | serge | 284 | crtc->cursor_y = os_display->height/2; |
285 | |||
286 | |||
287 | |||
288 | |||
3037 | serge | 289 | mode->hdisplay, mode->vdisplay, fb->pitches[0]); |
6283 | serge | 290 | } |
3031 | serge | 291 | else |
292 | DRM_ERROR("failed to set mode %d_%d on crtc %p\n", |
||
293 | fb->width, fb->height, crtc); |
||
294 | |||
295 | |||
6283 | serge | 296 | drm_modeset_unlock_all(dev); |
6084 | serge | 297 | |
298 | |||
3031 | serge | 299 | } |
300 | |||
301 | |||
6088 | serge | 302 | struct drm_connector *connector, struct drm_display_mode *mode) |
303 | { |
||
2338 | Serge | 304 | struct drm_i915_private *dev_priv = dev->dev_private; |
6088 | serge | 305 | struct drm_connector *tmpc; |
306 | struct drm_mode_config *config = &dev->mode_config; |
||
307 | struct drm_framebuffer *fb = NULL; |
||
308 | struct drm_mode_set set; |
||
309 | struct drm_crtc *crtc = NULL; |
||
6283 | serge | 310 | |
311 | |||
6088 | serge | 312 | int stride; |
313 | int ret; |
||
314 | |||
2338 | Serge | 315 | |
6283 | serge | 316 | if(fb == NULL) |
317 | { |
||
318 | DRM_ERROR("%s failed\n", __FUNCTION__); |
||
319 | return -1; |
||
320 | }; |
||
321 | drm_framebuffer_reference(fb); |
||
322 | |||
323 | |||
6088 | serge | 324 | |
325 | |||
326 | { |
||
2338 | Serge | 327 | const struct drm_connector_funcs *f = tmpc->funcs; |
6088 | serge | 328 | if(tmpc == connector) |
329 | continue; |
||
330 | f->dpms(tmpc, DRM_MODE_DPMS_OFF); |
||
331 | }; |
||
2338 | Serge | 332 | |
6088 | serge | 333 | |
6283 | serge | 334 | |
6088 | serge | 335 | |
336 | DRM_DEBUG_KMS("set mode %dx%d: crtc %d connector %s\n" |
||
337 | "monitor: %s model %x serial number %u\n", |
||
338 | mode->hdisplay, mode->vdisplay, |
||
6283 | serge | 339 | connector->encoder->crtc->base.id, connector->name, |
6088 | serge | 340 | manufacturer_name(con_edid + 0x08), |
341 | (unsigned short)(con_edid[0x0A] + (con_edid[0x0B] << 8)), |
||
342 | (unsigned int)(con_edid[0x0C] + (con_edid[0x0D] << 8) |
||
343 | + (con_edid[0x0E] << 16) + (con_edid[0x0F] << 24))); |
||
344 | |||
345 | |||
6283 | serge | 346 | |
347 | |||
348 | os_display->crtc = crtc; |
||
349 | |||
350 | |||
6088 | serge | 351 | fb,fb->width,fb->height,fb->pitches[0],fb->pixel_format); |
352 | |||
353 | |||
6283 | serge | 354 | set.x = 0; |
6088 | serge | 355 | set.y = 0; |
356 | set.mode = mode; |
||
357 | set.connectors = &connector; |
||
358 | set.num_connectors = 1; |
||
359 | set.fb = fb; |
||
360 | |||
361 | |||
362 | if ( !ret ) |
||
363 | { |
||
364 | struct intel_framebuffer *intel_fb = to_intel_framebuffer(fb); |
||
6283 | serge | 365 | struct kos_framebuffer *kfb = intel_fb->private; |
366 | kolibri_framebuffer_update(dev_priv, kfb); |
||
367 | DRM_DEBUG_KMS("kolibri framebuffer %p\n", kfb); |
||
368 | |||
6088 | serge | 369 | |
6283 | serge | 370 | os_display->height = mode->vdisplay; |
371 | os_display->vrefresh = drm_mode_vrefresh(mode); |
||
6088 | serge | 372 | sysSetFramebuffer(intel_fb->private); |
6283 | serge | 373 | sysSetScreen(mode->hdisplay, mode->vdisplay, fb->pitches[0]); |
374 | |||
6088 | serge | 375 | |
376 | os_display->crtc = connector->encoder->crtc; |
||
377 | os_display->supported_modes = count_connector_modes(connector); |
||
378 | |||
379 | |||
380 | crtc->cursor_y = os_display->height/2; |
||
381 | |||
382 | |||
6283 | serge | 383 | |
6088 | serge | 384 | |
385 | mode->hdisplay, mode->vdisplay, fb->pitches[0]); |
||
6283 | serge | 386 | } |
6088 | serge | 387 | else |
388 | DRM_ERROR(" failed to set mode %d_%d on crtc %p\n", |
||
389 | fb->width, fb->height, connector->encoder->crtc); |
||
390 | |||
391 | |||
6283 | serge | 392 | drm_modeset_unlock_all(dev); |
6088 | serge | 393 | return ret; |
394 | } |
||
395 | |||
396 | |||
397 | { |
||
398 | struct drm_display_mode *mode; |
||
399 | int retval; |
||
400 | |||
401 | |||
402 | if(mode == NULL) |
||
403 | return EINVAL; |
||
404 | |||
405 | |||
406 | |||
407 | |||
408 | return retval; |
||
409 | }; |
||
2338 | Serge | 410 | |
411 | |||
5060 | serge | 412 | { |
3031 | serge | 413 | struct drm_crtc *tmp_crtc; |
5060 | serge | 414 | int crtc_mask = 1; |
415 | |||
3031 | serge | 416 | |
5060 | serge | 417 | { |
3031 | serge | 418 | if (encoder->possible_crtcs & crtc_mask) |
5060 | serge | 419 | { |
6084 | serge | 420 | encoder->crtc = tmp_crtc; |
5060 | serge | 421 | DRM_DEBUG_KMS("use CRTC %p ID %d\n", tmp_crtc, tmp_crtc->base.id); |
422 | return tmp_crtc; |
||
423 | }; |
||
424 | crtc_mask <<= 1; |
||
425 | }; |
||
3031 | serge | 426 | return NULL; |
5060 | serge | 427 | }; |
3031 | serge | 428 | |
429 | |||
6088 | serge | 430 | { |
2338 | Serge | 431 | const struct drm_connector_helper_funcs *connector_funcs; |
6088 | serge | 432 | struct drm_encoder *encoder; |
4560 | Serge | 433 | struct drm_crtc *crtc; |
5060 | serge | 434 | |
2338 | Serge | 435 | |
6088 | serge | 436 | return -EINVAL; |
437 | |||
438 | |||
439 | |||
440 | |||
441 | { |
||
442 | connector_funcs = connector->helper_private; |
||
443 | encoder = connector_funcs->best_encoder(connector); |
||
444 | |||
445 | |||
446 | { |
||
447 | DRM_DEBUG_KMS("CONNECTOR %s ID: %d no active encoders\n", |
||
448 | connector->name, connector->base.id); |
||
449 | return -EINVAL; |
||
450 | }; |
||
451 | connector->encoder = encoder; |
||
6131 | serge | 452 | } |
6088 | serge | 453 | |
454 | |||
455 | if(crtc == NULL) |
||
456 | crtc = get_possible_crtc(dev, encoder); |
||
457 | |||
458 | |||
459 | { |
||
460 | DRM_DEBUG_KMS("%s connector: %p encode: %p crtc: %p\n",__FUNCTION__, |
||
6131 | serge | 461 | connector, encoder, crtc); |
462 | return 0; |
||
6088 | serge | 463 | } |
464 | else |
||
465 | DRM_DEBUG_KMS("No CRTC for encoder %d\n", encoder->base.id); |
||
466 | return -EINVAL; |
||
467 | } |
||
468 | |||
469 | |||
470 | { |
||
471 | struct drm_connector *connector; |
||
472 | |||
473 | |||
5060 | serge | 474 | { |
2338 | Serge | 475 | int name_len = __builtin_strlen(connector->name); |
6088 | serge | 476 | |
477 | |||
478 | continue; |
||
2338 | Serge | 479 | |
480 | |||
6088 | serge | 481 | continue; |
482 | |||
5060 | serge | 483 | |
6088 | serge | 484 | return connector; |
485 | } |
||
486 | return NULL; |
||
487 | } |
||
488 | |||
5060 | serge | 489 | |
2338 | Serge | 490 | |
6088 | serge | 491 | struct drm_crtc **boot_crtc) |
492 | { |
||
493 | struct drm_connector *connector; |
||
6103 | serge | 494 | |
4371 | Serge | 495 | |
6088 | serge | 496 | { |
497 | connector = get_cmdline_connector(dev, i915.cmdline_mode); |
||
498 | if(connector != NULL) |
||
499 | { |
||
5060 | serge | 500 | *boot_connector = connector; |
501 | *boot_crtc = connector->encoder->crtc; |
||
6088 | serge | 502 | return 0; |
5060 | serge | 503 | } |
504 | } |
||
6088 | serge | 505 | |
5060 | serge | 506 | |
6088 | serge | 507 | { |
508 | if(check_connector(dev, connector) == 0) |
||
509 | { |
||
510 | *boot_connector = connector; |
||
511 | *boot_crtc = connector->encoder->crtc; |
||
512 | return 0; |
||
513 | }; |
||
514 | }; |
||
2338 | Serge | 515 | |
516 | |||
5060 | serge | 517 | }; |
4398 | Serge | 518 | |
2338 | Serge | 519 | |
6103 | serge | 520 | |
5060 | serge | 521 | { |
4371 | Serge | 522 | struct drm_display_mode *mode; |
523 | |||
524 | |||
525 | { |
||
526 | if( os_display->width == mode->hdisplay && |
||
5060 | serge | 527 | os_display->height == mode->vdisplay && |
528 | drm_mode_vrefresh(mode) == 60) |
||
4371 | Serge | 529 | { |
530 | usermode->width = os_display->width; |
||
531 | usermode->height = os_display->height; |
||
532 | usermode->freq = 60; |
||
533 | return 1; |
||
534 | } |
||
535 | } |
||
536 | return 0; |
||
537 | } |
||
538 | |||
539 | |||
540 | { |
||
541 | struct drm_connector_helper_funcs *connector_funcs; |
||
542 | struct drm_connector *connector = NULL; |
||
5060 | serge | 543 | struct drm_crtc *crtc = NULL; |
544 | struct drm_plane *plane; |
||
6283 | serge | 545 | |
4371 | Serge | 546 | |
6084 | serge | 547 | ENTER(); |
6283 | serge | 548 | |
4371 | Serge | 549 | |
6283 | serge | 550 | { |
551 | drm_plane_helper_disable(plane); |
||
552 | }; |
||
553 | |||
554 | |||
4371 | Serge | 555 | ret = choose_config(dev, &connector, &crtc); |
5060 | serge | 556 | if(ret) |
557 | { |
||
4371 | Serge | 558 | mutex_unlock(&dev->mode_config.mutex); |
6088 | serge | 559 | DRM_DEBUG_KMS("No active connectors!\n"); |
4371 | Serge | 560 | return -1; |
561 | }; |
||
562 | |||
563 | |||
6283 | serge | 564 | mutex_lock(&dev->object_name_lock); |
5060 | serge | 565 | idr_preload(GFP_KERNEL); |
566 | if (!main_fb_obj->base.name) { |
||
567 | ret = idr_alloc(&dev->object_name_idr, &main_fb_obj->base, 1, 0, GFP_NOWAIT); |
||
568 | |||
4371 | Serge | 569 | |
5060 | serge | 570 | main_fb_obj->base.handle_count++; |
6084 | serge | 571 | DRM_DEBUG_KMS("%s allocate fb name %d\n", __FUNCTION__, main_fb_obj->base.name ); |
5060 | serge | 572 | } |
573 | idr_preload_end(); |
||
574 | mutex_unlock(&dev->object_name_lock); |
||
575 | */ |
||
6283 | serge | 576 | dummy_fb_page = AllocPage(); |
577 | |||
5060 | serge | 578 | |
2338 | Serge | 579 | os_display->ddev = dev; |
580 | os_display->connector = connector; |
||
581 | os_display->crtc = crtc; |
||
582 | os_display->supported_modes = count_connector_modes(connector); |
||
583 | mutex_unlock(&dev->mode_config.mutex); |
||
6088 | serge | 584 | |
2338 | Serge | 585 | |
6283 | serge | 586 | |
6088 | serge | 587 | |
588 | |||
589 | |||
590 | ret = set_cmdline_mode(dev, connector); |
||
591 | |||
592 | |||
593 | { |
||
4280 | Serge | 594 | mutex_lock(&dev->mode_config.mutex); |
6088 | serge | 595 | |
596 | |||
597 | (usermode->height == 0)) |
||
598 | { |
||
4371 | Serge | 599 | if( !get_boot_mode(connector, usermode)) |
6088 | serge | 600 | { |
601 | struct drm_display_mode *mode; |
||
602 | |||
4280 | Serge | 603 | |
6088 | serge | 604 | usermode->width = mode->hdisplay; |
605 | usermode->height = mode->vdisplay; |
||
606 | usermode->freq = drm_mode_vrefresh(mode); |
||
607 | }; |
||
608 | }; |
||
4280 | Serge | 609 | mutex_unlock(&dev->mode_config.mutex); |
6088 | serge | 610 | |
611 | |||
612 | }; |
||
4280 | Serge | 613 | |
614 | |||
6283 | serge | 615 | |
2340 | Serge | 616 | |
6088 | serge | 617 | }; |
2338 | Serge | 618 | |
619 | |||
620 | |||
6088 | serge | 621 | { |
622 | struct drm_connector_helper_funcs *connector_funcs; |
||
623 | struct drm_connector *connector; |
||
624 | struct drm_cmdline_mode cmd_mode = {0}; |
||
6103 | serge | 625 | struct drm_display_mode *mode; |
6088 | serge | 626 | char *mode_option; |
627 | int retval = 0; |
||
628 | char con_edid[128]; |
||
629 | |||
630 | |||
631 | return EINVAL; |
||
632 | |||
633 | |||
634 | connector = get_cmdline_connector(dev, cmdline); |
||
635 | mutex_unlock(&dev->mode_config.mutex); |
||
636 | |||
637 | |||
638 | return EINVAL; |
||
639 | |||
640 | |||
641 | if(mode_option == NULL) |
||
642 | return EINVAL; |
||
643 | |||
644 | |||
645 | |||
646 | |||
647 | return EINVAL; |
||
648 | |||
649 | |||
650 | connector->name, |
||
651 | cmd_mode.xres, cmd_mode.yres, |
||
652 | cmd_mode.refresh_specified ? cmd_mode.refresh : 60, |
||
653 | cmd_mode.rb ? " reduced blanking" : "", |
||
654 | cmd_mode.margins ? " with margins" : "", |
||
655 | cmd_mode.interlace ? " interlaced" : ""); |
||
656 | |||
657 | |||
658 | if(mode == NULL) |
||
659 | return EINVAL; |
||
660 | |||
661 | |||
662 | DRM_DEBUG_KMS("connector: %s monitor: %s model %x serial number %u\n", |
||
663 | connector->name, |
||
664 | manufacturer_name(con_edid + 0x08), |
||
665 | (unsigned short)(con_edid[0x0A] + (con_edid[0x0B] << 8)), |
||
666 | (unsigned int)(con_edid[0x0C] + (con_edid[0x0D] << 8) |
||
667 | + (con_edid[0x0E] << 16) + (con_edid[0x0F] << 24))); |
||
668 | |||
669 | |||
670 | |||
671 | |||
672 | |||
673 | |||
674 | } |
||
675 | |||
676 | |||
6103 | serge | 677 | { |
678 | struct drm_connector *connector; |
||
679 | char con_edid[128]; |
||
680 | |||
681 | |||
682 | list_for_each_entry(connector, &dev->mode_config.connector_list, head) |
||
683 | { |
||
684 | if( connector->status != connector_status_connected) |
||
685 | continue; |
||
686 | |||
687 | |||
688 | |||
689 | |||
690 | { |
||
691 | printf("%s mode %dx%d connected %s model %x serial number %u\n", |
||
692 | connector->name, os_display->width, os_display->height, |
||
693 | manufacturer_name(con_edid + 0x08), |
||
694 | (unsigned short)(con_edid[0x0A] + (con_edid[0x0B] << 8)), |
||
695 | (unsigned int)(con_edid[0x0C] + (con_edid[0x0D] << 8) |
||
696 | + (con_edid[0x0E] << 16) + (con_edid[0x0F] << 24))); |
||
697 | continue; |
||
698 | } |
||
699 | else |
||
700 | { |
||
701 | printf("%s connected: %s model %x serial number %u\n", |
||
702 | connector->name, manufacturer_name(con_edid + 0x08), |
||
703 | (unsigned short)(con_edid[0x0A] + (con_edid[0x0B] << 8)), |
||
704 | (unsigned int)(con_edid[0x0C] + (con_edid[0x0D] << 8) |
||
705 | + (con_edid[0x0E] << 16) + (con_edid[0x0F] << 24))); |
||
706 | } |
||
707 | }; |
||
708 | mutex_unlock(&dev->mode_config.mutex); |
||
709 | } |
||
710 | |||
711 | |||
712 | { |
||
713 | struct drm_connector *connector; |
||
714 | struct drm_display_mode *drmmode; |
||
715 | |||
716 | |||
717 | |||
718 | |||
719 | if(connector == NULL) |
||
720 | { |
||
721 | mutex_unlock(&dev->mode_config.mutex); |
||
722 | return EINVAL; |
||
723 | }; |
||
724 | |||
725 | |||
726 | |||
727 | |||
728 | { |
||
729 | printf("%dx%d@%d\n", drmmode->hdisplay, drmmode->vdisplay, drm_mode_vrefresh(drmmode)); |
||
730 | }; |
||
731 | |||
732 | |||
733 | return 0; |
||
734 | }; |
||
735 | |||
736 | |||
2338 | Serge | 737 | { |
738 | int err = -1; |
||
739 | |||
740 | |||
3031 | serge | 741 | |
2338 | Serge | 742 | |
743 | { |
||
744 | *count = os_display->supported_modes; |
||
745 | err = 0; |
||
746 | } |
||
747 | else if( mode != NULL ) |
||
748 | { |
||
749 | struct drm_display_mode *drmmode; |
||
750 | int i = 0; |
||
751 | |||
752 | |||
753 | *count = os_display->supported_modes; |
||
754 | |||
755 | |||
756 | { |
||
757 | if( i < *count) |
||
758 | { |
||
759 | mode->width = drmmode->hdisplay; |
||
5060 | serge | 760 | mode->height = drmmode->vdisplay; |
761 | mode->bpp = 32; |
||
2338 | Serge | 762 | mode->freq = drm_mode_vrefresh(drmmode); |
763 | i++; |
||
764 | mode++; |
||
765 | } |
||
766 | else break; |
||
767 | }; |
||
768 | *count = i; |
||
769 | err = 0; |
||
770 | }; |
||
771 | return err; |
||
772 | }; |
||
773 | |||
774 | |||
775 | { |
||
776 | |||
777 | |||
3031 | serge | 778 | // mode->width, mode->height, mode->freq); |
779 | |||
2338 | Serge | 780 | |
781 | (mode->height != 0) && |
||
782 | (mode->freq != 0 ) && |
||
783 | ( (mode->width != os_display->width) || |
||
784 | (mode->height != os_display->height) || |
||
785 | (mode->freq != os_display->vrefresh) ) ) |
||
786 | { |
||
787 | return set_mode(os_display->ddev, os_display->connector, os_display->crtc, mode, true); |
||
5060 | serge | 788 | }; |
2338 | Serge | 789 | |
790 | |||
5060 | serge | 791 | }; |
2338 | Serge | 792 | |
793 | |||
4126 | Serge | 794 | { |
795 | const struct drm_connector_funcs *f = os_display->connector->funcs; |
||
4371 | Serge | 796 | |
4126 | Serge | 797 | |
798 | }; |
||
799 | |||
800 | |||
6283 | serge | 801 | |
802 | { |
||
2338 | Serge | 803 | u32 ifl; |
6283 | serge | 804 | |
2342 | Serge | 805 | |
6283 | serge | 806 | { |
807 | struct drm_i915_private *dev_priv = os_display->ddev->dev_private; |
||
808 | struct intel_crtc *crtc = to_intel_crtc(os_display->crtc); |
||
809 | struct kos_framebuffer *kfb = os_display->current_lfb; |
||
810 | struct intel_framebuffer *intel_fb = (struct intel_framebuffer*)kfb->private; |
||
811 | struct drm_i915_gem_object *obj = intel_fb->obj; |
||
812 | |||
3037 | serge | 813 | |
6283 | serge | 814 | fb->width = os_display->width; |
815 | fb->height = os_display->height; |
||
816 | fb->pitch = obj->stride; |
||
817 | fb->tiling = obj->tiling_mode; |
||
818 | fb->crtc = crtc->base.base.id; |
||
819 | fb->pipe = crtc->pipe; |
||
820 | } |
||
821 | safe_sti(ifl); |
||
822 | return 0; |
||
823 | } |
||
824 | |||
3037 | serge | 825 | |
2338 | Serge | 826 | |
6283 | serge | 827 | { |
2338 | Serge | 828 | struct kos_framebuffer *kfb; |
6283 | serge | 829 | addr_t dummy_table; |
830 | addr_t *pt_addr = NULL; |
||
831 | int pde; |
||
832 | ENTER(); |
||
833 | kfb = kzalloc(sizeof(struct kos_framebuffer),0); |
||
834 | kfb->private = intel_fb; |
||
835 | |||
2338 | Serge | 836 | |
6283 | serge | 837 | { |
838 | dummy_table = AllocPage(); |
||
839 | kfb->pde[pde] = dummy_table|PG_UW; |
||
840 | |||
2338 | Serge | 841 | |
6283 | serge | 842 | __builtin_memset(pt_addr,0,4096); |
843 | kunmap((struct page*)dummy_table); |
||
844 | }; |
||
845 | |||
846 | |||
847 | LEAVE(); |
||
848 | return 0; |
||
849 | #if 0 |
||
850 | struct sg_page_iter sg_iter; |
||
851 | num_pages = obj->base.size/4096; |
||
852 | printf("num_pages %d\n",num_pages); |
||
853 | |||
854 | |||
855 | pde = 0; |
||
856 | pt_addr = NULL; |
||
857 | |||
858 | |||
859 | while (__sg_page_iter_next(&sg_iter)) |
||
860 | { |
||
2338 | Serge | 861 | if (pt_addr == NULL) |
6283 | serge | 862 | { |
863 | addr_t pt = AllocPage(); |
||
864 | kfb->pde[pde] = pt|PG_UW; |
||
865 | pde++; |
||
866 | pt_addr = kmap_atomic((struct page*)pt); |
||
867 | } |
||
2338 | Serge | 868 | pt_addr[pte] = sg_page_iter_dma_address(&sg_iter)|PG_UW|PG_WRITEC; |
6283 | serge | 869 | if( (pte & 15) == 0) |
870 | DRM_DEBUG_KMS("pte %x\n",pt_addr[pte]); |
||
871 | if (++pte == 1024) |
||
872 | { |
||
2338 | Serge | 873 | kunmap_atomic(pt_addr); |
6283 | serge | 874 | pt_addr = NULL; |
875 | if (pde == 8) |
||
876 | break; |
||
877 | pte = 0; |
||
878 | } |
||
2338 | Serge | 879 | } |
6283 | serge | 880 | |
2338 | Serge | 881 | |
6283 | serge | 882 | { |
4104 | Serge | 883 | for(;pte < 1024; pte++) |
6283 | serge | 884 | pt_addr[pte] = dummy_page|PG_UW; |
885 | kunmap_atomic(pt_addr); |
||
886 | } |
||
4104 | Serge | 887 | #endif |
6283 | serge | 888 | }; |
889 | |||
2338 | Serge | 890 | |
6283 | serge | 891 | { |
892 | struct intel_framebuffer *intel_fb = kfb->private; |
||
893 | addr_t *pt_addr = NULL; |
||
894 | int pte = 0; |
||
895 | int pde = 0; |
||
896 | int num_pages; |
||
897 | addr_t pfn; |
||
898 | ENTER(); |
||
899 | num_pages = intel_fb->obj->base.size/4096; |
||
900 | pfn = dev_priv->gtt.mappable_base + i915_gem_obj_ggtt_offset(intel_fb->obj); |
||
901 | |||
2338 | Serge | 902 | |
6283 | serge | 903 | { |
2338 | Serge | 904 | if (pt_addr == NULL) |
6283 | serge | 905 | { |
906 | addr_t pt = kfb->pde[pde] & 0xFFFFF000; |
||
907 | pde++; |
||
908 | pt_addr = kmap_atomic((struct page*)pt); |
||
909 | } |
||
910 | pt_addr[pte] = pfn|PG_UW|PG_WRITEC; |
||
911 | pfn+= 4096; |
||
912 | num_pages--; |
||
913 | if (++pte == 1024) |
||
914 | { |
||
915 | kunmap_atomic(pt_addr); |
||
916 | pt_addr = NULL; |
||
917 | if (pde == 8) |
||
918 | break; |
||
919 | pte = 0; |
||
920 | } |
||
921 | } |
||
922 | |||
2338 | Serge | 923 | |
6283 | serge | 924 | { |
2338 | Serge | 925 | for(;pte < 1024; pte++) |
6283 | serge | 926 | pt_addr[pte] = dummy_fb_page|PG_UW; |
927 | kunmap_atomic(pt_addr); |
||
928 | } |
||
2338 | Serge | 929 | LEAVE(); |
6283 | serge | 930 | }; |
2338 | Serge | 931 | |
932 | |||
3277 | Serge | 933 | { |
934 | int left; |
||
935 | int top; |
||
936 | int right; |
||
937 | int bottom; |
||
938 | }rect_t; |
||
939 | |||
3263 | Serge | 940 | |
3277 | Serge | 941 | |
942 | |||
943 | |||
944 | |||
945 | |||
946 | struct drm_file *file) |
||
947 | { |
||
948 | struct drm_i915_mask *mask = data; |
||
949 | struct drm_gem_object *obj; |
||
950 | static unsigned int mask_seqno[256]; |
||
951 | rect_t winrc; |
||
952 | u32 slot; |
||
953 | int ret=0; |
||
4371 | Serge | 954 | |
3277 | Serge | 955 | |
956 | if (obj == NULL) |
||
957 | return -ENOENT; |
||
958 | |||
959 | |||
960 | drm_gem_object_unreference_unlocked(obj); |
||
961 | return -EINVAL; |
||
962 | } |
||
963 | |||
964 | |||
965 | { |
||
966 | // static warn_count; |
||
3298 | Serge | 967 | |
3277 | Serge | 968 | |
3290 | Serge | 969 | mask->height = winrc.bottom - winrc.top + 1; |
970 | mask->bo_pitch = (mask->width+15) & ~15; |
||
971 | |||
972 | |||
3298 | Serge | 973 | if(warn_count < 1) |
3277 | Serge | 974 | { |
975 | printf("left %d top %d right %d bottom %d\n", |
||
976 | winrc.left, winrc.top, winrc.right, winrc.bottom); |
||
977 | printf("mask pitch %d data %p\n", mask->bo_pitch, mask->bo_map); |
||
5060 | serge | 978 | warn_count++; |
3277 | Serge | 979 | }; |
980 | #endif |
||
3298 | Serge | 981 | |
982 | |||
4104 | Serge | 983 | |
3277 | Serge | 984 | |
3290 | Serge | 985 | |
3277 | Serge | 986 | |
987 | |||
988 | { |
||
989 | u8* src_offset; |
||
990 | u8* dst_offset; |
||
991 | u32 ifl; |
||
992 | |||
993 | |||
994 | if (ret) |
||
995 | goto err1; |
||
4371 | Serge | 996 | |
3277 | Serge | 997 | |
998 | if(ret != 0 ) |
||
4398 | Serge | 999 | { |
3277 | Serge | 1000 | dbgprintf("%s: i915_gem_object_set_to_cpu_domain failed\n", __FUNCTION__); |
4371 | Serge | 1001 | goto err2; |
1002 | }; |
||
3277 | Serge | 1003 | |
1004 | |||
1005 | |||
1006 | |||
1007 | |||
1008 | |||
5354 | serge | 1009 | src_offset+= winrc.top*os_display->width + winrc.left; |
1010 | |||
3277 | Serge | 1011 | |
1012 | |||
1013 | |||
5354 | serge | 1014 | |
3277 | Serge | 1015 | |
1016 | { |
||
1017 | mask_seqno[slot] = os_display->mask_seqno; |
||
1018 | |||
1019 | |||
1020 | |||
1021 | |||
1022 | "movd %[slot], %%xmm6 \n" |
||
4560 | Serge | 1023 | "punpckldq %%xmm6, %%xmm6 \n" |
3277 | Serge | 1024 | "punpcklqdq %%xmm6, %%xmm6 \n" |
1025 | :: [slot] "m" (slot) |
||
1026 | :"xmm6"); |
||
1027 | |||
1028 | |||
1029 | { |
||
1030 | int tmp_w = mask->width; |
||
4398 | Serge | 1031 | |
3277 | Serge | 1032 | |
1033 | u8* tmp_dst = dst_offset; |
||
1034 | |||
1035 | |||
1036 | dst_offset+= mask->bo_pitch; |
||
1037 | |||
1038 | |||
1039 | { |
||
1040 | __asm__ __volatile__ ( |
||
1041 | "movdqu (%0), %%xmm0 \n" |
||
1042 | "movdqu 16(%0), %%xmm1 \n" |
||
1043 | "movdqu 32(%0), %%xmm2 \n" |
||
1044 | "movdqu 48(%0), %%xmm3 \n" |
||
1045 | "pcmpeqb %%xmm6, %%xmm0 \n" |
||
1046 | "pcmpeqb %%xmm6, %%xmm1 \n" |
||
1047 | "pcmpeqb %%xmm6, %%xmm2 \n" |
||
1048 | "pcmpeqb %%xmm6, %%xmm3 \n" |
||
1049 | "movdqa %%xmm0, (%%edi) \n" |
||
1050 | "movdqa %%xmm1, 16(%%edi) \n" |
||
1051 | "movdqa %%xmm2, 32(%%edi) \n" |
||
1052 | "movdqa %%xmm3, 48(%%edi) \n" |
||
1053 | |||
1054 | |||
1055 | :"xmm0","xmm1","xmm2","xmm3"); |
||
1056 | tmp_w -= 64; |
||
1057 | tmp_src += 64; |
||
1058 | tmp_dst += 64; |
||
1059 | } |
||
1060 | |||
1061 | |||
1062 | { |
||
1063 | __asm__ __volatile__ ( |
||
1064 | "movdqu (%0), %%xmm0 \n" |
||
1065 | "movdqu 16(%0), %%xmm1 \n" |
||
1066 | "pcmpeqb %%xmm6, %%xmm0 \n" |
||
1067 | "pcmpeqb %%xmm6, %%xmm1 \n" |
||
1068 | "movdqa %%xmm0, (%%edi) \n" |
||
1069 | "movdqa %%xmm1, 16(%%edi) \n" |
||
1070 | |||
1071 | |||
1072 | :"xmm0","xmm1"); |
||
1073 | tmp_w -= 32; |
||
1074 | tmp_src += 32; |
||
1075 | tmp_dst += 32; |
||
1076 | } |
||
1077 | |||
1078 | |||
4398 | Serge | 1079 | { |
3277 | Serge | 1080 | __asm__ __volatile__ ( |
1081 | "movdqu (%0), %%xmm0 \n" |
||
1082 | "pcmpeqb %%xmm6, %%xmm0 \n" |
||
1083 | "movdqa %%xmm0, (%%edi) \n" |
||
1084 | :: "r" (tmp_src), "D" (tmp_dst) |
||
1085 | :"xmm0"); |
||
1086 | tmp_w -= 16; |
||
1087 | tmp_src += 16; |
||
1088 | tmp_dst += 16; |
||
1089 | } |
||
1090 | |||
4398 | Serge | 1091 | |
1092 | { |
||
1093 | __asm__ __volatile__ ( |
||
1094 | "movq (%0), %%xmm0 \n" |
||
1095 | "pcmpeqb %%xmm6, %%xmm0 \n" |
||
1096 | "movq %%xmm0, (%%edi) \n" |
||
1097 | :: "r" (tmp_src), "D" (tmp_dst) |
||
1098 | :"xmm0"); |
||
1099 | tmp_w -= 8; |
||
1100 | tmp_src += 8; |
||
1101 | tmp_dst += 8; |
||
1102 | } |
||
1103 | if( tmp_w >= 4 ) |
||
1104 | { |
||
1105 | __asm__ __volatile__ ( |
||
1106 | "movd (%0), %%xmm0 \n" |
||
1107 | "pcmpeqb %%xmm6, %%xmm0 \n" |
||
1108 | "movd %%xmm0, (%%edi) \n" |
||
1109 | :: "r" (tmp_src), "D" (tmp_dst) |
||
1110 | :"xmm0"); |
||
1111 | tmp_w -= 4; |
||
1112 | tmp_src += 4; |
||
1113 | tmp_dst += 4; |
||
1114 | } |
||
1115 | while(tmp_w--) |
||
1116 | *tmp_dst++ = (*tmp_src++ == (u8)slot) ? 0xFF:0x00; |
||
1117 | }; |
||
3277 | Serge | 1118 | }; |
1119 | safe_sti(ifl); |
||
1120 | |||
4371 | Serge | 1121 | |
1122 | } |
||
4539 | Serge | 1123 | |
1124 | |||
1125 | mutex_unlock(&dev->struct_mutex); |
||
1126 | err1: |
||
1127 | drm_gem_object_unreference(obj); |
||
1128 | |||
1129 | |||
1130 | } |
||
1131 | |||
1132 | |||
1133 | struct drm_file *file) |
||
1134 | { |
||
1135 | struct drm_i915_mask_update *mask = data; |
||
1136 | struct drm_gem_object *obj; |
||
1137 | static unsigned int mask_seqno[256]; |
||
1138 | static warn_count; |
||
1139 | |||
1140 | |||
1141 | u32 winw,winh; |
||
1142 | u32 ml,mt,mr,mb; |
||
1143 | u32 slot; |
||
1144 | int ret = 0; |
||
1145 | slot = *((u8*)CURRENT_TASK); |
||
1146 | |||
1147 | |||
6084 | serge | 1148 | return 0; |
4539 | Serge | 1149 | |
1150 | |||
6084 | serge | 1151 | memset((void*)mask->bo_map,0,mask->width * mask->height); |
1152 | |||
5367 | serge | 1153 | |
4539 | Serge | 1154 | win.right+= 1; |
1155 | win.bottom+= 1; |
||
1156 | |||
1157 | |||
1158 | winh = win.bottom - win.top; |
||
1159 | |||
1160 | |||
1161 | mask->dy >= winh) |
||
1162 | return 1; |
||
1163 | |||
1164 | |||
1165 | mt = win.top + mask->dy; |
||
1166 | mr = ml + mask->width; |
||
1167 | mb = mt + mask->height; |
||
1168 | |||
1169 | |||
1170 | mr < win.left || mb < win.top ) |
||
1171 | return 1; |
||
1172 | |||
1173 | |||
1174 | mr = win.right; |
||
1175 | |||
1176 | |||
1177 | mb = win.bottom; |
||
1178 | |||
1179 | |||
1180 | mask->height = mb - mt; |
||
1181 | |||
1182 | |||
1183 | mask->height== 0 ) |
||
1184 | return 1; |
||
1185 | |||
1186 | |||
6131 | serge | 1187 | if (ret) |
1188 | return ret; |
||
1189 | |||
1190 | |||
4539 | Serge | 1191 | if (obj == NULL) |
1192 | { |
||
6131 | serge | 1193 | ret = -ENOENT; |
1194 | goto unlock; |
||
1195 | } |
||
1196 | |||
4539 | Serge | 1197 | |
6131 | serge | 1198 | { |
1199 | ret = -ENOENT; |
||
1200 | goto out; |
||
1201 | } |
||
4539 | Serge | 1202 | |
1203 | |||
6084 | serge | 1204 | if(warn_count < 100) |
1205 | { |
||
4539 | Serge | 1206 | printf("left %d top %d right %d bottom %d\n", |
1207 | ml, mt, mr, mb); |
||
1208 | warn_count++; |
||
1209 | }; |
||
1210 | #endif |
||
1211 | |||
1212 | |||
1213 | |||
1214 | |||
1215 | |||
1216 | u8* src_offset; |
||
1217 | u8* dst_offset; |
||
1218 | u32 ifl; |
||
1219 | |||
1220 | |||
1221 | |||
1222 | |||
5354 | serge | 1223 | src_offset+= mt*os_display->width + ml; |
1224 | dst_offset = (u8*)mask->bo_map; |
||
4539 | Serge | 1225 | |
1226 | |||
5354 | serge | 1227 | |
4539 | Serge | 1228 | |
1229 | { |
||
4371 | Serge | 1230 | mask_seqno[slot] = os_display->mask_seqno; |
4539 | Serge | 1231 | |
1232 | |||
1233 | |||
1234 | |||
1235 | "movd %[slot], %%xmm6 \n" |
||
1236 | "punpckldq %%xmm6, %%xmm6 \n" |
||
1237 | "punpcklqdq %%xmm6, %%xmm6 \n" |
||
1238 | :: [slot] "m" (slot) |
||
1239 | :"xmm6"); |
||
1240 | |||
1241 | |||
1242 | { |
||
1243 | int tmp_w = mask->width; |
||
1244 | |||
1245 | |||
1246 | u8* tmp_dst = dst_offset; |
||
1247 | |||
1248 | |||
1249 | dst_offset+= mask->bo_pitch; |
||
1250 | |||
1251 | |||
1252 | { |
||
1253 | __asm__ __volatile__ ( |
||
1254 | "movdqu (%0), %%xmm0 \n" |
||
1255 | "movdqu 16(%0), %%xmm1 \n" |
||
1256 | "movdqu 32(%0), %%xmm2 \n" |
||
1257 | "movdqu 48(%0), %%xmm3 \n" |
||
1258 | "pcmpeqb %%xmm6, %%xmm0 \n" |
||
1259 | "pcmpeqb %%xmm6, %%xmm1 \n" |
||
1260 | "pcmpeqb %%xmm6, %%xmm2 \n" |
||
1261 | "pcmpeqb %%xmm6, %%xmm3 \n" |
||
1262 | "movdqa %%xmm0, (%%edi) \n" |
||
1263 | "movdqa %%xmm1, 16(%%edi) \n" |
||
1264 | "movdqa %%xmm2, 32(%%edi) \n" |
||
1265 | "movdqa %%xmm3, 48(%%edi) \n" |
||
1266 | |||
1267 | |||
1268 | :"xmm0","xmm1","xmm2","xmm3"); |
||
1269 | tmp_w -= 64; |
||
1270 | tmp_src += 64; |
||
1271 | tmp_dst += 64; |
||
1272 | } |
||
1273 | |||
1274 | |||
1275 | { |
||
1276 | __asm__ __volatile__ ( |
||
1277 | "movdqu (%0), %%xmm0 \n" |
||
1278 | "movdqu 16(%0), %%xmm1 \n" |
||
1279 | "pcmpeqb %%xmm6, %%xmm0 \n" |
||
1280 | "pcmpeqb %%xmm6, %%xmm1 \n" |
||
1281 | "movdqa %%xmm0, (%%edi) \n" |
||
1282 | "movdqa %%xmm1, 16(%%edi) \n" |
||
1283 | |||
1284 | |||
1285 | :"xmm0","xmm1"); |
||
1286 | tmp_w -= 32; |
||
1287 | tmp_src += 32; |
||
1288 | tmp_dst += 32; |
||
1289 | } |
||
1290 | |||
1291 | |||
1292 | { |
||
1293 | __asm__ __volatile__ ( |
||
1294 | "movdqu (%0), %%xmm0 \n" |
||
1295 | "pcmpeqb %%xmm6, %%xmm0 \n" |
||
1296 | "movdqa %%xmm0, (%%edi) \n" |
||
1297 | :: "r" (tmp_src), "D" (tmp_dst) |
||
1298 | :"xmm0"); |
||
1299 | tmp_w -= 16; |
||
1300 | tmp_src += 16; |
||
1301 | tmp_dst += 16; |
||
1302 | } |
||
1303 | |||
1304 | |||
1305 | { |
||
1306 | __asm__ __volatile__ ( |
||
1307 | "movq (%0), %%xmm0 \n" |
||
1308 | "pcmpeqb %%xmm6, %%xmm0 \n" |
||
1309 | "movq %%xmm0, (%%edi) \n" |
||
1310 | :: "r" (tmp_src), "D" (tmp_dst) |
||
1311 | :"xmm0"); |
||
1312 | tmp_w -= 8; |
||
1313 | tmp_src += 8; |
||
1314 | tmp_dst += 8; |
||
1315 | } |
||
1316 | if( tmp_w >= 4 ) |
||
1317 | { |
||
4560 | Serge | 1318 | __asm__ __volatile__ ( |
4539 | Serge | 1319 | "movd (%0), %%xmm0 \n" |
1320 | "pcmpeqb %%xmm6, %%xmm0 \n" |
||
1321 | "movd %%xmm0, (%%edi) \n" |
||
1322 | :: "r" (tmp_src), "D" (tmp_dst) |
||
1323 | :"xmm0"); |
||
1324 | tmp_w -= 4; |
||
1325 | tmp_src += 4; |
||
1326 | tmp_dst += 4; |
||
1327 | } |
||
1328 | while(tmp_w--) |
||
1329 | *tmp_dst++ = (*tmp_src++ == (u8)slot) ? 0xFF:0x00; |
||
1330 | }; |
||
1331 | }; |
||
4371 | Serge | 1332 | safe_sti(ifl); |
4539 | Serge | 1333 | |
1334 | |||
1335 | } |
||
3277 | Serge | 1336 | #endif |
4539 | Serge | 1337 | |
3277 | Serge | 1338 | |
6131 | serge | 1339 | drm_gem_object_unreference(obj); |
3277 | Serge | 1340 | |
1341 | |||
6131 | serge | 1342 | mutex_unlock(&dev->struct_mutex); |
1343 | |||
1344 | |||
4371 | Serge | 1345 | } |
3277 | Serge | 1346 | |
1347 | |||
1348 | |||
1349 | |||
2360 | Serge | 1350 | |
3031 | serge | 1351 | |
2360 | Serge | 1352 | |
3031 | serge | 1353 | { |
1354 | u32 tmp = GetTimerTicks(); |
||
1355 | |||
2360 | Serge | 1356 | |
3031 | serge | 1357 | ts->tv_nsec = (tmp - ts->tv_sec*100)*10000000; |
1358 | } |
||
1359 | |||
2360 | Serge | 1360 | |
6084 | serge | 1361 | { |
3031 | serge | 1362 | unsigned long flags; |
3480 | Serge | 1363 | |
3031 | serge | 1364 | |
3480 | Serge | 1365 | spin_lock_irqsave(&q->lock, flags); |
1366 | if (list_empty(&wait->task_list)) |
||
1367 | __add_wait_queue(q, wait); |
||
1368 | spin_unlock_irqrestore(&q->lock, flags); |
||
1369 | } |
||
1370 | |||
1371 | |||
1372 | * finish_wait - clean up after waiting in a queue |
||
1373 | * @q: waitqueue waited on |
||
1374 | * @wait: wait descriptor |
||
1375 | * |
||
1376 | * Sets current thread back to running state and removes |
||
1377 | * the wait descriptor from the given waitqueue if still |
||
1378 | * queued. |
||
1379 | */ |
||
1380 | void finish_wait(wait_queue_head_t *q, wait_queue_t *wait) |
||
1381 | { |
||
1382 | unsigned long flags; |
||
1383 | |||
1384 | |||
1385 | /* |
||
1386 | * We can check for list emptiness outside the lock |
||
1387 | * IFF: |
||
1388 | * - we use the "careful" check that verifies both |
||
1389 | * the next and prev pointers, so that there cannot |
||
1390 | * be any half-pending updates in progress on other |
||
1391 | * CPU's that we haven't seen yet (and that might |
||
1392 | * still change the stack area. |
||
1393 | * and |
||
1394 | * - all other users take the lock (ie we can only |
||
1395 | * have _one_ other CPU that looks at or modifies |
||
1396 | * the list). |
||
1397 | */ |
||
1398 | if (!list_empty_careful(&wait->task_list)) { |
||
1399 | spin_lock_irqsave(&q->lock, flags); |
||
1400 | list_del_init(&wait->task_list); |
||
1401 | spin_unlock_irqrestore(&q->lock, flags); |
||
1402 | } |
||
1403 | |||
1404 | |||
1405 | } |
||
1406 | |||
1407 | |||
1408 | { |
||
1409 | list_del_init(&wait->task_list); |
||
1410 | return 1; |
||
1411 | }24); |
||
1412 | |||
1413 | |||
1414 | |||
1415 |