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