Rev 6296 | Rev 6660 | 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 | #include |
||
5354 | serge | 13 | |
2338 | Serge | 14 | |
6283 | serge | 15 | |
2338 | Serge | 16 | |
5354 | serge | 17 | |
2338 | Serge | 18 | |
5354 | serge | 19 | u32 cmd_offset; |
20 | |||
2340 | Serge | 21 | |
2351 | Serge | 22 | int sna_init(); |
23 | |||
24 | |||
3031 | serge | 25 | { |
26 | static char name[4]; |
||
27 | |||
28 | |||
29 | name[1] = ((x[0] & 0x03) << 3) + ((x[1] & 0xE0) >> 5) + '@'; |
||
30 | name[2] = (x[1] & 0x1F) + '@'; |
||
31 | name[3] = 0; |
||
32 | |||
33 | |||
34 | } |
||
35 | |||
36 | |||
6088 | serge | 37 | { |
38 | struct drm_display_mode *mode; |
||
39 | int count = 0; |
||
40 | |||
41 | |||
42 | count++; |
||
43 | |||
44 | |||
45 | }; |
||
46 | |||
47 | |||
6283 | serge | 48 | { |
49 | struct drm_i915_private *dev_priv = dev->dev_private; |
||
6320 | serge | 50 | struct intel_fbdev *ifbdev = dev_priv->fbdev; |
51 | struct intel_framebuffer *intel_fb = ifbdev->fb; |
||
52 | struct drm_framebuffer *fb = &intel_fb->base; |
||
53 | struct drm_i915_gem_object *obj = NULL; |
||
6283 | serge | 54 | int stride, size; |
55 | |||
56 | |||
57 | |||
58 | |||
6320 | serge | 59 | tiling = 0; |
60 | |||
61 | |||
6283 | serge | 62 | { |
63 | int gen3size; |
||
64 | |||
65 | |||
66 | size = stride * ALIGN(mode->vdisplay, 8); |
||
67 | size = ALIGN(size, 4096); |
||
68 | } |
||
69 | else |
||
70 | { |
||
71 | stride = ALIGN(stride, 64); |
||
72 | size = stride * ALIGN(mode->vdisplay, 2); |
||
73 | } |
||
74 | |||
75 | |||
6296 | serge | 76 | |
6283 | serge | 77 | |
78 | { |
||
79 | struct drm_mode_fb_cmd2 mode_cmd = {}; |
||
80 | int ret; |
||
81 | |||
82 | |||
83 | set_fake_framebuffer(); |
||
6320 | serge | 84 | drm_framebuffer_remove(fb); |
6283 | serge | 85 | ifbdev->fb = NULL; |
86 | fb = NULL; |
||
87 | DRM_DEBUG_KMS("create new framebuffer\n"); |
||
88 | |||
89 | |||
90 | mode_cmd.height = mode->vdisplay; |
||
91 | |||
92 | |||
93 | mode_cmd.pixel_format = DRM_FORMAT_XRGB8888; |
||
94 | |||
95 | |||
96 | |||
97 | |||
98 | * important and we should probably use that space with FBC or other |
||
99 | * features. */ |
||
100 | if (size * 2 < dev_priv->gtt.stolen_usable_size) |
||
101 | obj = i915_gem_object_create_stolen(dev, size); |
||
102 | if (obj == NULL) |
||
103 | obj = i915_gem_alloc_object(dev, size); |
||
104 | if (!obj) { |
||
105 | DRM_ERROR("failed to allocate framebuffer\n"); |
||
106 | ret = -ENOMEM; |
||
107 | goto out; |
||
108 | } |
||
109 | |||
110 | |||
111 | if (IS_ERR(fb)) { |
||
112 | ret = PTR_ERR(fb); |
||
113 | goto out_unref; |
||
114 | } |
||
115 | |||
116 | |||
117 | ret = intel_pin_and_fence_fb_obj(NULL, fb, NULL, NULL, NULL); |
||
118 | if (ret) { |
||
119 | DRM_ERROR("failed to pin obj: %d\n", ret); |
||
120 | goto out_fb; |
||
121 | } |
||
122 | mutex_unlock(&dev->struct_mutex); |
||
123 | ifbdev->fb = to_intel_framebuffer(fb); |
||
124 | } |
||
125 | |||
126 | |||
127 | |||
128 | |||
129 | { |
||
130 | obj->tiling_mode = I915_TILING_X; |
||
131 | fb->modifier[0] = I915_FORMAT_MOD_X_TILED; |
||
132 | obj->fence_dirty = true; |
||
133 | obj->stride = stride; |
||
134 | }; |
||
135 | |||
136 | |||
6296 | serge | 137 | { |
138 | int ret; |
||
139 | |||
140 | |||
141 | idr_preload(GFP_KERNEL); |
||
142 | ret = idr_alloc(&dev->object_name_idr, &obj->base, 1, 0, GFP_NOWAIT); |
||
143 | idr_preload_end(); |
||
144 | mutex_unlock(&dev->object_name_lock); |
||
145 | obj->base.name = ret; |
||
146 | obj->base.handle_count++; |
||
147 | DRM_DEBUG_KMS("%s allocate fb name %d\n", __FUNCTION__, obj->base.name ); |
||
148 | } |
||
149 | |||
150 | |||
6283 | serge | 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 | |||
6320 | serge | 161 | |
6283 | serge | 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; |
6296 | serge | 176 | struct drm_mode_config *config = &dev->mode_config; |
177 | struct drm_display_mode *mode = NULL, *tmpmode; |
||
178 | struct drm_connector *tmpc; |
||
6088 | serge | 179 | struct drm_framebuffer *fb = NULL; |
6296 | serge | 180 | struct drm_mode_set set; |
3031 | serge | 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), |
||
6296 | 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 | |||
6088 | serge | 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, kfb); |
||
6320 | serge | 271 | DRM_DEBUG_KMS("kolibri framebuffer %p\n", kfb); |
6283 | serge | 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, kfb); |
||
6320 | serge | 367 | DRM_DEBUG_KMS("kolibri framebuffer %p\n", kfb); |
6283 | serge | 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 | |
6296 | 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 | |||
2338 | Serge | 564 | os_display->ddev = dev; |
565 | os_display->connector = connector; |
||
566 | os_display->crtc = crtc; |
||
567 | os_display->supported_modes = count_connector_modes(connector); |
||
568 | mutex_unlock(&dev->mode_config.mutex); |
||
6088 | serge | 569 | |
2338 | Serge | 570 | |
6283 | serge | 571 | |
6088 | serge | 572 | |
573 | |||
574 | |||
575 | ret = set_cmdline_mode(dev, connector); |
||
576 | |||
577 | |||
578 | { |
||
4280 | Serge | 579 | mutex_lock(&dev->mode_config.mutex); |
6088 | serge | 580 | |
581 | |||
582 | (usermode->height == 0)) |
||
583 | { |
||
4371 | Serge | 584 | if( !get_boot_mode(connector, usermode)) |
6088 | serge | 585 | { |
586 | struct drm_display_mode *mode; |
||
587 | |||
4280 | Serge | 588 | |
6088 | serge | 589 | usermode->width = mode->hdisplay; |
590 | usermode->height = mode->vdisplay; |
||
591 | usermode->freq = drm_mode_vrefresh(mode); |
||
592 | }; |
||
593 | }; |
||
4280 | Serge | 594 | mutex_unlock(&dev->mode_config.mutex); |
6088 | serge | 595 | |
596 | |||
597 | }; |
||
4280 | Serge | 598 | |
599 | |||
6283 | serge | 600 | |
2340 | Serge | 601 | |
6088 | serge | 602 | }; |
2338 | Serge | 603 | |
604 | |||
605 | |||
6088 | serge | 606 | { |
607 | struct drm_connector_helper_funcs *connector_funcs; |
||
608 | struct drm_connector *connector; |
||
609 | struct drm_cmdline_mode cmd_mode = {0}; |
||
6103 | serge | 610 | struct drm_display_mode *mode; |
6088 | serge | 611 | char *mode_option; |
612 | int retval = 0; |
||
613 | char con_edid[128]; |
||
614 | |||
615 | |||
616 | return EINVAL; |
||
617 | |||
618 | |||
619 | connector = get_cmdline_connector(dev, cmdline); |
||
620 | mutex_unlock(&dev->mode_config.mutex); |
||
621 | |||
622 | |||
623 | return EINVAL; |
||
624 | |||
625 | |||
626 | if(mode_option == NULL) |
||
627 | return EINVAL; |
||
628 | |||
629 | |||
630 | |||
631 | |||
632 | return EINVAL; |
||
633 | |||
634 | |||
635 | connector->name, |
||
636 | cmd_mode.xres, cmd_mode.yres, |
||
637 | cmd_mode.refresh_specified ? cmd_mode.refresh : 60, |
||
638 | cmd_mode.rb ? " reduced blanking" : "", |
||
639 | cmd_mode.margins ? " with margins" : "", |
||
640 | cmd_mode.interlace ? " interlaced" : ""); |
||
641 | |||
642 | |||
643 | if(mode == NULL) |
||
644 | return EINVAL; |
||
645 | |||
646 | |||
647 | DRM_DEBUG_KMS("connector: %s monitor: %s model %x serial number %u\n", |
||
648 | connector->name, |
||
649 | manufacturer_name(con_edid + 0x08), |
||
650 | (unsigned short)(con_edid[0x0A] + (con_edid[0x0B] << 8)), |
||
651 | (unsigned int)(con_edid[0x0C] + (con_edid[0x0D] << 8) |
||
652 | + (con_edid[0x0E] << 16) + (con_edid[0x0F] << 24))); |
||
653 | |||
654 | |||
655 | |||
656 | |||
657 | |||
658 | |||
659 | } |
||
660 | |||
661 | |||
6103 | serge | 662 | { |
663 | struct drm_connector *connector; |
||
664 | char con_edid[128]; |
||
665 | |||
666 | |||
667 | list_for_each_entry(connector, &dev->mode_config.connector_list, head) |
||
668 | { |
||
669 | if( connector->status != connector_status_connected) |
||
670 | continue; |
||
671 | |||
672 | |||
673 | |||
674 | |||
675 | { |
||
676 | printf("%s mode %dx%d connected %s model %x serial number %u\n", |
||
677 | connector->name, os_display->width, os_display->height, |
||
678 | manufacturer_name(con_edid + 0x08), |
||
679 | (unsigned short)(con_edid[0x0A] + (con_edid[0x0B] << 8)), |
||
680 | (unsigned int)(con_edid[0x0C] + (con_edid[0x0D] << 8) |
||
681 | + (con_edid[0x0E] << 16) + (con_edid[0x0F] << 24))); |
||
682 | continue; |
||
683 | } |
||
684 | else |
||
685 | { |
||
686 | printf("%s connected: %s model %x serial number %u\n", |
||
687 | connector->name, manufacturer_name(con_edid + 0x08), |
||
688 | (unsigned short)(con_edid[0x0A] + (con_edid[0x0B] << 8)), |
||
689 | (unsigned int)(con_edid[0x0C] + (con_edid[0x0D] << 8) |
||
690 | + (con_edid[0x0E] << 16) + (con_edid[0x0F] << 24))); |
||
691 | } |
||
692 | }; |
||
693 | mutex_unlock(&dev->mode_config.mutex); |
||
694 | } |
||
695 | |||
696 | |||
697 | { |
||
698 | struct drm_connector *connector; |
||
699 | struct drm_display_mode *drmmode; |
||
700 | |||
701 | |||
702 | |||
703 | |||
704 | if(connector == NULL) |
||
705 | { |
||
706 | mutex_unlock(&dev->mode_config.mutex); |
||
707 | return EINVAL; |
||
708 | }; |
||
709 | |||
710 | |||
711 | |||
712 | |||
713 | { |
||
714 | printf("%dx%d@%d\n", drmmode->hdisplay, drmmode->vdisplay, drm_mode_vrefresh(drmmode)); |
||
715 | }; |
||
716 | |||
717 | |||
718 | return 0; |
||
719 | }; |
||
720 | |||
721 | |||
2338 | Serge | 722 | { |
723 | int err = -1; |
||
724 | |||
725 | |||
3031 | serge | 726 | |
2338 | Serge | 727 | |
728 | { |
||
729 | *count = os_display->supported_modes; |
||
730 | err = 0; |
||
731 | } |
||
732 | else if( mode != NULL ) |
||
733 | { |
||
734 | struct drm_display_mode *drmmode; |
||
735 | int i = 0; |
||
736 | |||
737 | |||
738 | *count = os_display->supported_modes; |
||
739 | |||
740 | |||
741 | { |
||
742 | if( i < *count) |
||
743 | { |
||
744 | mode->width = drmmode->hdisplay; |
||
5060 | serge | 745 | mode->height = drmmode->vdisplay; |
746 | mode->bpp = 32; |
||
2338 | Serge | 747 | mode->freq = drm_mode_vrefresh(drmmode); |
748 | i++; |
||
749 | mode++; |
||
750 | } |
||
751 | else break; |
||
752 | }; |
||
753 | *count = i; |
||
754 | err = 0; |
||
755 | }; |
||
756 | return err; |
||
757 | }; |
||
758 | |||
759 | |||
760 | { |
||
761 | |||
762 | |||
3031 | serge | 763 | // mode->width, mode->height, mode->freq); |
764 | |||
2338 | Serge | 765 | |
766 | (mode->height != 0) && |
||
767 | (mode->freq != 0 ) && |
||
768 | ( (mode->width != os_display->width) || |
||
769 | (mode->height != os_display->height) || |
||
770 | (mode->freq != os_display->vrefresh) ) ) |
||
771 | { |
||
772 | return set_mode(os_display->ddev, os_display->connector, os_display->crtc, mode, true); |
||
5060 | serge | 773 | }; |
2338 | Serge | 774 | |
775 | |||
5060 | serge | 776 | }; |
2338 | Serge | 777 | |
778 | |||
4126 | Serge | 779 | { |
780 | const struct drm_connector_funcs *f = os_display->connector->funcs; |
||
4371 | Serge | 781 | |
4126 | Serge | 782 | |
783 | }; |
||
784 | |||
785 | |||
6283 | serge | 786 | |
787 | { |
||
2338 | Serge | 788 | u32 ifl; |
6283 | serge | 789 | |
2342 | Serge | 790 | |
6283 | serge | 791 | { |
792 | struct drm_i915_private *dev_priv = os_display->ddev->dev_private; |
||
793 | struct intel_crtc *crtc = to_intel_crtc(os_display->crtc); |
||
794 | struct kos_framebuffer *kfb = os_display->current_lfb; |
||
795 | struct intel_framebuffer *intel_fb = (struct intel_framebuffer*)kfb->private; |
||
796 | struct drm_i915_gem_object *obj = intel_fb->obj; |
||
797 | |||
3037 | serge | 798 | |
6283 | serge | 799 | fb->width = os_display->width; |
800 | fb->height = os_display->height; |
||
801 | fb->pitch = os_display->lfb_pitch; |
||
6320 | serge | 802 | fb->tiling = obj->tiling_mode; |
6283 | serge | 803 | fb->crtc = crtc->base.base.id; |
804 | fb->pipe = crtc->pipe; |
||
805 | } |
||
806 | safe_sti(ifl); |
||
807 | |||
6296 | serge | 808 | |
6283 | serge | 809 | } |
810 | |||
3037 | serge | 811 | |
6296 | serge | 812 | |
3277 | Serge | 813 | { |
814 | int left; |
||
815 | int top; |
||
816 | int right; |
||
817 | int bottom; |
||
818 | }rect_t; |
||
819 | |||
3263 | Serge | 820 | |
3277 | Serge | 821 | |
822 | |||
823 | |||
824 | |||
825 | |||
826 | struct drm_file *file) |
||
827 | { |
||
828 | struct drm_i915_mask *mask = data; |
||
829 | struct drm_gem_object *obj; |
||
830 | static unsigned int mask_seqno[256]; |
||
831 | rect_t winrc; |
||
832 | u32 slot; |
||
833 | int ret=0; |
||
4371 | Serge | 834 | |
3277 | Serge | 835 | |
836 | if (obj == NULL) |
||
837 | return -ENOENT; |
||
838 | |||
839 | |||
840 | drm_gem_object_unreference_unlocked(obj); |
||
841 | return -EINVAL; |
||
842 | } |
||
843 | |||
844 | |||
845 | { |
||
846 | // static warn_count; |
||
3298 | Serge | 847 | |
3277 | Serge | 848 | |
3290 | Serge | 849 | mask->height = winrc.bottom - winrc.top + 1; |
850 | mask->bo_pitch = (mask->width+15) & ~15; |
||
851 | |||
852 | |||
3298 | Serge | 853 | if(warn_count < 1) |
3277 | Serge | 854 | { |
855 | printf("left %d top %d right %d bottom %d\n", |
||
856 | winrc.left, winrc.top, winrc.right, winrc.bottom); |
||
857 | printf("mask pitch %d data %p\n", mask->bo_pitch, mask->bo_map); |
||
5060 | serge | 858 | warn_count++; |
3277 | Serge | 859 | }; |
860 | #endif |
||
3298 | Serge | 861 | |
862 | |||
4104 | Serge | 863 | |
3277 | Serge | 864 | |
3290 | Serge | 865 | |
3277 | Serge | 866 | |
867 | |||
868 | { |
||
869 | u8* src_offset; |
||
870 | u8* dst_offset; |
||
871 | u32 ifl; |
||
872 | |||
873 | |||
874 | if (ret) |
||
875 | goto err1; |
||
4371 | Serge | 876 | |
3277 | Serge | 877 | |
878 | if(ret != 0 ) |
||
4398 | Serge | 879 | { |
3277 | Serge | 880 | dbgprintf("%s: i915_gem_object_set_to_cpu_domain failed\n", __FUNCTION__); |
4371 | Serge | 881 | goto err2; |
882 | }; |
||
3277 | Serge | 883 | |
884 | |||
885 | |||
886 | |||
887 | |||
888 | |||
5354 | serge | 889 | src_offset+= winrc.top*os_display->width + winrc.left; |
890 | |||
3277 | Serge | 891 | |
892 | |||
893 | |||
5354 | serge | 894 | |
3277 | Serge | 895 | |
896 | { |
||
897 | mask_seqno[slot] = os_display->mask_seqno; |
||
898 | |||
899 | |||
900 | |||
901 | |||
902 | "movd %[slot], %%xmm6 \n" |
||
4560 | Serge | 903 | "punpckldq %%xmm6, %%xmm6 \n" |
3277 | Serge | 904 | "punpcklqdq %%xmm6, %%xmm6 \n" |
905 | :: [slot] "m" (slot) |
||
906 | :"xmm6"); |
||
907 | |||
908 | |||
909 | { |
||
910 | int tmp_w = mask->width; |
||
4398 | Serge | 911 | |
3277 | Serge | 912 | |
913 | u8* tmp_dst = dst_offset; |
||
914 | |||
915 | |||
916 | dst_offset+= mask->bo_pitch; |
||
917 | |||
918 | |||
919 | { |
||
920 | __asm__ __volatile__ ( |
||
921 | "movdqu (%0), %%xmm0 \n" |
||
922 | "movdqu 16(%0), %%xmm1 \n" |
||
923 | "movdqu 32(%0), %%xmm2 \n" |
||
924 | "movdqu 48(%0), %%xmm3 \n" |
||
925 | "pcmpeqb %%xmm6, %%xmm0 \n" |
||
926 | "pcmpeqb %%xmm6, %%xmm1 \n" |
||
927 | "pcmpeqb %%xmm6, %%xmm2 \n" |
||
928 | "pcmpeqb %%xmm6, %%xmm3 \n" |
||
929 | "movdqa %%xmm0, (%%edi) \n" |
||
930 | "movdqa %%xmm1, 16(%%edi) \n" |
||
931 | "movdqa %%xmm2, 32(%%edi) \n" |
||
932 | "movdqa %%xmm3, 48(%%edi) \n" |
||
933 | |||
934 | |||
935 | :"xmm0","xmm1","xmm2","xmm3"); |
||
936 | tmp_w -= 64; |
||
937 | tmp_src += 64; |
||
938 | tmp_dst += 64; |
||
939 | } |
||
940 | |||
941 | |||
942 | { |
||
943 | __asm__ __volatile__ ( |
||
944 | "movdqu (%0), %%xmm0 \n" |
||
945 | "movdqu 16(%0), %%xmm1 \n" |
||
946 | "pcmpeqb %%xmm6, %%xmm0 \n" |
||
947 | "pcmpeqb %%xmm6, %%xmm1 \n" |
||
948 | "movdqa %%xmm0, (%%edi) \n" |
||
949 | "movdqa %%xmm1, 16(%%edi) \n" |
||
950 | |||
951 | |||
952 | :"xmm0","xmm1"); |
||
953 | tmp_w -= 32; |
||
954 | tmp_src += 32; |
||
955 | tmp_dst += 32; |
||
956 | } |
||
957 | |||
958 | |||
4398 | Serge | 959 | { |
3277 | Serge | 960 | __asm__ __volatile__ ( |
961 | "movdqu (%0), %%xmm0 \n" |
||
962 | "pcmpeqb %%xmm6, %%xmm0 \n" |
||
963 | "movdqa %%xmm0, (%%edi) \n" |
||
964 | :: "r" (tmp_src), "D" (tmp_dst) |
||
965 | :"xmm0"); |
||
966 | tmp_w -= 16; |
||
967 | tmp_src += 16; |
||
968 | tmp_dst += 16; |
||
969 | } |
||
970 | |||
4398 | Serge | 971 | |
972 | { |
||
973 | __asm__ __volatile__ ( |
||
974 | "movq (%0), %%xmm0 \n" |
||
975 | "pcmpeqb %%xmm6, %%xmm0 \n" |
||
976 | "movq %%xmm0, (%%edi) \n" |
||
977 | :: "r" (tmp_src), "D" (tmp_dst) |
||
978 | :"xmm0"); |
||
979 | tmp_w -= 8; |
||
980 | tmp_src += 8; |
||
981 | tmp_dst += 8; |
||
982 | } |
||
983 | if( tmp_w >= 4 ) |
||
984 | { |
||
985 | __asm__ __volatile__ ( |
||
986 | "movd (%0), %%xmm0 \n" |
||
987 | "pcmpeqb %%xmm6, %%xmm0 \n" |
||
988 | "movd %%xmm0, (%%edi) \n" |
||
989 | :: "r" (tmp_src), "D" (tmp_dst) |
||
990 | :"xmm0"); |
||
991 | tmp_w -= 4; |
||
992 | tmp_src += 4; |
||
993 | tmp_dst += 4; |
||
994 | } |
||
995 | while(tmp_w--) |
||
996 | *tmp_dst++ = (*tmp_src++ == (u8)slot) ? 0xFF:0x00; |
||
997 | }; |
||
3277 | Serge | 998 | }; |
999 | safe_sti(ifl); |
||
1000 | |||
4371 | Serge | 1001 | |
1002 | } |
||
4539 | Serge | 1003 | |
1004 | |||
1005 | mutex_unlock(&dev->struct_mutex); |
||
1006 | err1: |
||
1007 | drm_gem_object_unreference(obj); |
||
1008 | |||
1009 | |||
1010 | } |
||
1011 | |||
1012 | |||
1013 | struct drm_file *file) |
||
1014 | { |
||
1015 | struct drm_i915_mask_update *mask = data; |
||
1016 | struct drm_gem_object *obj; |
||
1017 | static unsigned int mask_seqno[256]; |
||
1018 | static warn_count; |
||
1019 | |||
1020 | |||
1021 | u32 winw,winh; |
||
1022 | u32 ml,mt,mr,mb; |
||
1023 | u32 slot; |
||
1024 | int ret = 0; |
||
1025 | slot = *((u8*)CURRENT_TASK); |
||
1026 | |||
1027 | |||
6084 | serge | 1028 | return 0; |
4539 | Serge | 1029 | |
1030 | |||
6084 | serge | 1031 | memset((void*)mask->bo_map,0,mask->width * mask->height); |
1032 | |||
5367 | serge | 1033 | |
4539 | Serge | 1034 | win.right+= 1; |
1035 | win.bottom+= 1; |
||
1036 | |||
1037 | |||
1038 | winh = win.bottom - win.top; |
||
1039 | |||
1040 | |||
1041 | mask->dy >= winh) |
||
1042 | return 1; |
||
1043 | |||
1044 | |||
1045 | mt = win.top + mask->dy; |
||
1046 | mr = ml + mask->width; |
||
1047 | mb = mt + mask->height; |
||
1048 | |||
1049 | |||
1050 | mr < win.left || mb < win.top ) |
||
1051 | return 1; |
||
1052 | |||
1053 | |||
1054 | mr = win.right; |
||
1055 | |||
1056 | |||
1057 | mb = win.bottom; |
||
1058 | |||
1059 | |||
1060 | mask->height = mb - mt; |
||
1061 | |||
1062 | |||
1063 | mask->height== 0 ) |
||
1064 | return 1; |
||
1065 | |||
1066 | |||
6131 | serge | 1067 | if (ret) |
1068 | return ret; |
||
1069 | |||
1070 | |||
4539 | Serge | 1071 | if (obj == NULL) |
1072 | { |
||
6131 | serge | 1073 | ret = -ENOENT; |
1074 | goto unlock; |
||
1075 | } |
||
1076 | |||
4539 | Serge | 1077 | |
6131 | serge | 1078 | { |
1079 | ret = -ENOENT; |
||
1080 | goto out; |
||
1081 | } |
||
4539 | Serge | 1082 | |
1083 | |||
6084 | serge | 1084 | if(warn_count < 100) |
1085 | { |
||
4539 | Serge | 1086 | printf("left %d top %d right %d bottom %d\n", |
1087 | ml, mt, mr, mb); |
||
1088 | warn_count++; |
||
1089 | }; |
||
1090 | #endif |
||
1091 | |||
1092 | |||
1093 | |||
1094 | |||
1095 | |||
1096 | u8* src_offset; |
||
1097 | u8* dst_offset; |
||
1098 | u32 ifl; |
||
1099 | |||
1100 | |||
1101 | |||
1102 | |||
5354 | serge | 1103 | src_offset+= mt*os_display->width + ml; |
1104 | dst_offset = (u8*)mask->bo_map; |
||
4539 | Serge | 1105 | |
1106 | |||
5354 | serge | 1107 | |
4539 | Serge | 1108 | |
1109 | { |
||
4371 | Serge | 1110 | mask_seqno[slot] = os_display->mask_seqno; |
4539 | Serge | 1111 | |
1112 | |||
1113 | |||
1114 | |||
1115 | "movd %[slot], %%xmm6 \n" |
||
1116 | "punpckldq %%xmm6, %%xmm6 \n" |
||
1117 | "punpcklqdq %%xmm6, %%xmm6 \n" |
||
1118 | :: [slot] "m" (slot) |
||
1119 | :"xmm6"); |
||
1120 | |||
1121 | |||
1122 | { |
||
1123 | int tmp_w = mask->width; |
||
1124 | |||
1125 | |||
1126 | u8* tmp_dst = dst_offset; |
||
1127 | |||
1128 | |||
1129 | dst_offset+= mask->bo_pitch; |
||
1130 | |||
1131 | |||
1132 | { |
||
1133 | __asm__ __volatile__ ( |
||
1134 | "movdqu (%0), %%xmm0 \n" |
||
1135 | "movdqu 16(%0), %%xmm1 \n" |
||
1136 | "movdqu 32(%0), %%xmm2 \n" |
||
1137 | "movdqu 48(%0), %%xmm3 \n" |
||
1138 | "pcmpeqb %%xmm6, %%xmm0 \n" |
||
1139 | "pcmpeqb %%xmm6, %%xmm1 \n" |
||
1140 | "pcmpeqb %%xmm6, %%xmm2 \n" |
||
1141 | "pcmpeqb %%xmm6, %%xmm3 \n" |
||
1142 | "movdqa %%xmm0, (%%edi) \n" |
||
1143 | "movdqa %%xmm1, 16(%%edi) \n" |
||
1144 | "movdqa %%xmm2, 32(%%edi) \n" |
||
1145 | "movdqa %%xmm3, 48(%%edi) \n" |
||
1146 | |||
1147 | |||
1148 | :"xmm0","xmm1","xmm2","xmm3"); |
||
1149 | tmp_w -= 64; |
||
1150 | tmp_src += 64; |
||
1151 | tmp_dst += 64; |
||
1152 | } |
||
1153 | |||
1154 | |||
1155 | { |
||
1156 | __asm__ __volatile__ ( |
||
1157 | "movdqu (%0), %%xmm0 \n" |
||
1158 | "movdqu 16(%0), %%xmm1 \n" |
||
1159 | "pcmpeqb %%xmm6, %%xmm0 \n" |
||
1160 | "pcmpeqb %%xmm6, %%xmm1 \n" |
||
1161 | "movdqa %%xmm0, (%%edi) \n" |
||
1162 | "movdqa %%xmm1, 16(%%edi) \n" |
||
1163 | |||
1164 | |||
1165 | :"xmm0","xmm1"); |
||
1166 | tmp_w -= 32; |
||
1167 | tmp_src += 32; |
||
1168 | tmp_dst += 32; |
||
1169 | } |
||
1170 | |||
1171 | |||
1172 | { |
||
1173 | __asm__ __volatile__ ( |
||
1174 | "movdqu (%0), %%xmm0 \n" |
||
1175 | "pcmpeqb %%xmm6, %%xmm0 \n" |
||
1176 | "movdqa %%xmm0, (%%edi) \n" |
||
1177 | :: "r" (tmp_src), "D" (tmp_dst) |
||
1178 | :"xmm0"); |
||
1179 | tmp_w -= 16; |
||
1180 | tmp_src += 16; |
||
1181 | tmp_dst += 16; |
||
1182 | } |
||
1183 | |||
1184 | |||
1185 | { |
||
1186 | __asm__ __volatile__ ( |
||
1187 | "movq (%0), %%xmm0 \n" |
||
1188 | "pcmpeqb %%xmm6, %%xmm0 \n" |
||
1189 | "movq %%xmm0, (%%edi) \n" |
||
1190 | :: "r" (tmp_src), "D" (tmp_dst) |
||
1191 | :"xmm0"); |
||
1192 | tmp_w -= 8; |
||
1193 | tmp_src += 8; |
||
1194 | tmp_dst += 8; |
||
1195 | } |
||
1196 | if( tmp_w >= 4 ) |
||
1197 | { |
||
4560 | Serge | 1198 | __asm__ __volatile__ ( |
4539 | Serge | 1199 | "movd (%0), %%xmm0 \n" |
1200 | "pcmpeqb %%xmm6, %%xmm0 \n" |
||
1201 | "movd %%xmm0, (%%edi) \n" |
||
1202 | :: "r" (tmp_src), "D" (tmp_dst) |
||
1203 | :"xmm0"); |
||
1204 | tmp_w -= 4; |
||
1205 | tmp_src += 4; |
||
1206 | tmp_dst += 4; |
||
1207 | } |
||
1208 | while(tmp_w--) |
||
1209 | *tmp_dst++ = (*tmp_src++ == (u8)slot) ? 0xFF:0x00; |
||
1210 | }; |
||
1211 | }; |
||
4371 | Serge | 1212 | safe_sti(ifl); |
4539 | Serge | 1213 | |
1214 | |||
1215 | } |
||
3277 | Serge | 1216 | #endif |
4539 | Serge | 1217 | |
3277 | Serge | 1218 | |
6131 | serge | 1219 | drm_gem_object_unreference(obj); |
3277 | Serge | 1220 | |
1221 | |||
6131 | serge | 1222 | mutex_unlock(&dev->struct_mutex); |
1223 | |||
1224 | |||
4371 | Serge | 1225 | } |
3277 | Serge | 1226 | |
1227 | |||
1228 | |||
1229 | |||
2360 | Serge | 1230 | |
3031 | serge | 1231 | |
2360 | Serge | 1232 | |
3031 | serge | 1233 | { |
1234 | u32 tmp = GetTimerTicks(); |
||
1235 | |||
2360 | Serge | 1236 | |
3031 | serge | 1237 | ts->tv_nsec = (tmp - ts->tv_sec*100)*10000000; |
1238 | } |
||
1239 | |||
2360 | Serge | 1240 | |
6084 | serge | 1241 | { |
3031 | serge | 1242 | unsigned long flags; |
3480 | Serge | 1243 | |
3031 | serge | 1244 | |
3480 | Serge | 1245 | spin_lock_irqsave(&q->lock, flags); |
1246 | if (list_empty(&wait->task_list)) |
||
1247 | __add_wait_queue(q, wait); |
||
1248 | spin_unlock_irqrestore(&q->lock, flags); |
||
1249 | } |
||
1250 | |||
1251 | |||
1252 | * finish_wait - clean up after waiting in a queue |
||
1253 | * @q: waitqueue waited on |
||
1254 | * @wait: wait descriptor |
||
1255 | * |
||
1256 | * Sets current thread back to running state and removes |
||
1257 | * the wait descriptor from the given waitqueue if still |
||
1258 | * queued. |
||
1259 | */ |
||
1260 | void finish_wait(wait_queue_head_t *q, wait_queue_t *wait) |
||
1261 | { |
||
1262 | unsigned long flags; |
||
1263 | |||
1264 | |||
1265 | /* |
||
1266 | * We can check for list emptiness outside the lock |
||
1267 | * IFF: |
||
1268 | * - we use the "careful" check that verifies both |
||
1269 | * the next and prev pointers, so that there cannot |
||
1270 | * be any half-pending updates in progress on other |
||
1271 | * CPU's that we haven't seen yet (and that might |
||
1272 | * still change the stack area. |
||
1273 | * and |
||
1274 | * - all other users take the lock (ie we can only |
||
1275 | * have _one_ other CPU that looks at or modifies |
||
1276 | * the list). |
||
1277 | */ |
||
1278 | if (!list_empty_careful(&wait->task_list)) { |
||
1279 | spin_lock_irqsave(&q->lock, flags); |
||
1280 | list_del_init(&wait->task_list); |
||
1281 | spin_unlock_irqrestore(&q->lock, flags); |
||
1282 | } |
||
1283 | |||
1284 | |||
1285 | } |
||
1286 | |||
1287 | |||
1288 | { |
||
1289 | list_del_init(&wait->task_list); |
||
1290 | return 1; |
||
1291 | }24); |
||
1292 |