1 /* 2 * Copyright (C) 2017 Samsung Electronics Co.Ltd 3 * Authors: 4 * Marek Szyprowski <m.szyprowski@samsung.com> 5 * 6 * Exynos DRM Image Post Processing (IPP) related functions 7 * 8 * Permission is hereby granted, free of charge, to any person obtaining a 9 * copy of this software and associated documentation files (the "Software"), 10 * to deal in the Software without restriction, including without limitation 11 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 12 * and/or sell copies of the Software, and to permit persons to whom the 13 * Software is furnished to do so, subject to the following conditions: 14 * 15 * The above copyright notice and this permission notice shall be included in 16 * all copies or substantial portions of the Software. 17 */ 18 19 #include <drm/drmP.h> 20 #include <drm/drm_mode.h> 21 #include <drm/exynos_drm.h> 22 23 #include "exynos_drm_drv.h" 24 #include "exynos_drm_gem.h" 25 #include "exynos_drm_ipp.h" 26 27 static int num_ipp; 28 static LIST_HEAD(ipp_list); 29 30 /** 31 * exynos_drm_ipp_register - Register a new picture processor hardware module 32 * @dev: DRM device 33 * @ipp: ipp module to init 34 * @funcs: callbacks for the new ipp object 35 * @caps: bitmask of ipp capabilities (%DRM_EXYNOS_IPP_CAP_*) 36 * @formats: array of supported formats 37 * @num_formats: size of the supported formats array 38 * @name: name (for debugging purposes) 39 * 40 * Initializes a ipp module. 41 * 42 * Returns: 43 * Zero on success, error code on failure. 44 */ 45 int exynos_drm_ipp_register(struct device *dev, struct exynos_drm_ipp *ipp, 46 const struct exynos_drm_ipp_funcs *funcs, unsigned int caps, 47 const struct exynos_drm_ipp_formats *formats, 48 unsigned int num_formats, const char *name) 49 { 50 WARN_ON(!ipp); 51 WARN_ON(!funcs); 52 WARN_ON(!formats); 53 WARN_ON(!num_formats); 54 55 spin_lock_init(&ipp->lock); 56 INIT_LIST_HEAD(&ipp->todo_list); 57 init_waitqueue_head(&ipp->done_wq); 58 ipp->dev = dev; 59 ipp->funcs = funcs; 60 ipp->capabilities = caps; 61 ipp->name = name; 62 ipp->formats = formats; 63 ipp->num_formats = num_formats; 64 65 /* ipp_list modification is serialized by component framework */ 66 list_add_tail(&ipp->head, &ipp_list); 67 ipp->id = num_ipp++; 68 69 DRM_DEV_DEBUG_DRIVER(dev, "Registered ipp %d\n", ipp->id); 70 71 return 0; 72 } 73 74 /** 75 * exynos_drm_ipp_unregister - Unregister the picture processor module 76 * @dev: DRM device 77 * @ipp: ipp module 78 */ 79 void exynos_drm_ipp_unregister(struct device *dev, 80 struct exynos_drm_ipp *ipp) 81 { 82 WARN_ON(ipp->task); 83 WARN_ON(!list_empty(&ipp->todo_list)); 84 list_del(&ipp->head); 85 } 86 87 /** 88 * exynos_drm_ipp_ioctl_get_res_ioctl - enumerate all ipp modules 89 * @dev: DRM device 90 * @data: ioctl data 91 * @file_priv: DRM file info 92 * 93 * Construct a list of ipp ids. 94 * 95 * Called by the user via ioctl. 96 * 97 * Returns: 98 * Zero on success, negative errno on failure. 99 */ 100 int exynos_drm_ipp_get_res_ioctl(struct drm_device *dev, void *data, 101 struct drm_file *file_priv) 102 { 103 struct drm_exynos_ioctl_ipp_get_res *resp = data; 104 struct exynos_drm_ipp *ipp; 105 uint32_t __user *ipp_ptr = (uint32_t __user *) 106 (unsigned long)resp->ipp_id_ptr; 107 unsigned int count = num_ipp, copied = 0; 108 109 /* 110 * This ioctl is called twice, once to determine how much space is 111 * needed, and the 2nd time to fill it. 112 */ 113 if (count && resp->count_ipps >= count) { 114 list_for_each_entry(ipp, &ipp_list, head) { 115 if (put_user(ipp->id, ipp_ptr + copied)) 116 return -EFAULT; 117 copied++; 118 } 119 } 120 resp->count_ipps = count; 121 122 return 0; 123 } 124 125 static inline struct exynos_drm_ipp *__ipp_get(uint32_t id) 126 { 127 struct exynos_drm_ipp *ipp; 128 129 list_for_each_entry(ipp, &ipp_list, head) 130 if (ipp->id == id) 131 return ipp; 132 return NULL; 133 } 134 135 /** 136 * exynos_drm_ipp_ioctl_get_caps - get ipp module capabilities and formats 137 * @dev: DRM device 138 * @data: ioctl data 139 * @file_priv: DRM file info 140 * 141 * Construct a structure describing ipp module capabilities. 142 * 143 * Called by the user via ioctl. 144 * 145 * Returns: 146 * Zero on success, negative errno on failure. 147 */ 148 int exynos_drm_ipp_get_caps_ioctl(struct drm_device *dev, void *data, 149 struct drm_file *file_priv) 150 { 151 struct drm_exynos_ioctl_ipp_get_caps *resp = data; 152 void __user *ptr = (void __user *)(unsigned long)resp->formats_ptr; 153 struct exynos_drm_ipp *ipp; 154 int i; 155 156 ipp = __ipp_get(resp->ipp_id); 157 if (!ipp) 158 return -ENOENT; 159 160 resp->ipp_id = ipp->id; 161 resp->capabilities = ipp->capabilities; 162 163 /* 164 * This ioctl is called twice, once to determine how much space is 165 * needed, and the 2nd time to fill it. 166 */ 167 if (resp->formats_count >= ipp->num_formats) { 168 for (i = 0; i < ipp->num_formats; i++) { 169 struct drm_exynos_ipp_format tmp = { 170 .fourcc = ipp->formats[i].fourcc, 171 .type = ipp->formats[i].type, 172 .modifier = ipp->formats[i].modifier, 173 }; 174 175 if (copy_to_user(ptr, &tmp, sizeof(tmp))) 176 return -EFAULT; 177 ptr += sizeof(tmp); 178 } 179 } 180 resp->formats_count = ipp->num_formats; 181 182 return 0; 183 } 184 185 static inline const struct exynos_drm_ipp_formats *__ipp_format_get( 186 struct exynos_drm_ipp *ipp, uint32_t fourcc, 187 uint64_t mod, unsigned int type) 188 { 189 int i; 190 191 for (i = 0; i < ipp->num_formats; i++) { 192 if ((ipp->formats[i].type & type) && 193 ipp->formats[i].fourcc == fourcc && 194 ipp->formats[i].modifier == mod) 195 return &ipp->formats[i]; 196 } 197 return NULL; 198 } 199 200 /** 201 * exynos_drm_ipp_get_limits_ioctl - get ipp module limits 202 * @dev: DRM device 203 * @data: ioctl data 204 * @file_priv: DRM file info 205 * 206 * Construct a structure describing ipp module limitations for provided 207 * picture format. 208 * 209 * Called by the user via ioctl. 210 * 211 * Returns: 212 * Zero on success, negative errno on failure. 213 */ 214 int exynos_drm_ipp_get_limits_ioctl(struct drm_device *dev, void *data, 215 struct drm_file *file_priv) 216 { 217 struct drm_exynos_ioctl_ipp_get_limits *resp = data; 218 void __user *ptr = (void __user *)(unsigned long)resp->limits_ptr; 219 const struct exynos_drm_ipp_formats *format; 220 struct exynos_drm_ipp *ipp; 221 222 if (resp->type != DRM_EXYNOS_IPP_FORMAT_SOURCE && 223 resp->type != DRM_EXYNOS_IPP_FORMAT_DESTINATION) 224 return -EINVAL; 225 226 ipp = __ipp_get(resp->ipp_id); 227 if (!ipp) 228 return -ENOENT; 229 230 format = __ipp_format_get(ipp, resp->fourcc, resp->modifier, 231 resp->type); 232 if (!format) 233 return -EINVAL; 234 235 /* 236 * This ioctl is called twice, once to determine how much space is 237 * needed, and the 2nd time to fill it. 238 */ 239 if (format->num_limits && resp->limits_count >= format->num_limits) 240 if (copy_to_user((void __user *)ptr, format->limits, 241 sizeof(*format->limits) * format->num_limits)) 242 return -EFAULT; 243 resp->limits_count = format->num_limits; 244 245 return 0; 246 } 247 248 struct drm_pending_exynos_ipp_event { 249 struct drm_pending_event base; 250 struct drm_exynos_ipp_event event; 251 }; 252 253 static inline struct exynos_drm_ipp_task * 254 exynos_drm_ipp_task_alloc(struct exynos_drm_ipp *ipp) 255 { 256 struct exynos_drm_ipp_task *task; 257 258 task = kzalloc(sizeof(*task), GFP_KERNEL); 259 if (!task) 260 return NULL; 261 262 task->dev = ipp->dev; 263 task->ipp = ipp; 264 265 /* some defaults */ 266 task->src.rect.w = task->dst.rect.w = UINT_MAX; 267 task->src.rect.h = task->dst.rect.h = UINT_MAX; 268 task->transform.rotation = DRM_MODE_ROTATE_0; 269 270 DRM_DEV_DEBUG_DRIVER(task->dev, "Allocated task %pK\n", task); 271 272 return task; 273 } 274 275 static const struct exynos_drm_param_map { 276 unsigned int id; 277 unsigned int size; 278 unsigned int offset; 279 } exynos_drm_ipp_params_maps[] = { 280 { 281 DRM_EXYNOS_IPP_TASK_BUFFER | DRM_EXYNOS_IPP_TASK_TYPE_SOURCE, 282 sizeof(struct drm_exynos_ipp_task_buffer), 283 offsetof(struct exynos_drm_ipp_task, src.buf), 284 }, { 285 DRM_EXYNOS_IPP_TASK_BUFFER | 286 DRM_EXYNOS_IPP_TASK_TYPE_DESTINATION, 287 sizeof(struct drm_exynos_ipp_task_buffer), 288 offsetof(struct exynos_drm_ipp_task, dst.buf), 289 }, { 290 DRM_EXYNOS_IPP_TASK_RECTANGLE | DRM_EXYNOS_IPP_TASK_TYPE_SOURCE, 291 sizeof(struct drm_exynos_ipp_task_rect), 292 offsetof(struct exynos_drm_ipp_task, src.rect), 293 }, { 294 DRM_EXYNOS_IPP_TASK_RECTANGLE | 295 DRM_EXYNOS_IPP_TASK_TYPE_DESTINATION, 296 sizeof(struct drm_exynos_ipp_task_rect), 297 offsetof(struct exynos_drm_ipp_task, dst.rect), 298 }, { 299 DRM_EXYNOS_IPP_TASK_TRANSFORM, 300 sizeof(struct drm_exynos_ipp_task_transform), 301 offsetof(struct exynos_drm_ipp_task, transform), 302 }, { 303 DRM_EXYNOS_IPP_TASK_ALPHA, 304 sizeof(struct drm_exynos_ipp_task_alpha), 305 offsetof(struct exynos_drm_ipp_task, alpha), 306 }, 307 }; 308 309 static int exynos_drm_ipp_task_set(struct exynos_drm_ipp_task *task, 310 struct drm_exynos_ioctl_ipp_commit *arg) 311 { 312 const struct exynos_drm_param_map *map = exynos_drm_ipp_params_maps; 313 void __user *params = (void __user *)(unsigned long)arg->params_ptr; 314 unsigned int size = arg->params_size; 315 uint32_t id; 316 int i; 317 318 while (size) { 319 if (get_user(id, (uint32_t __user *)params)) 320 return -EFAULT; 321 322 for (i = 0; i < ARRAY_SIZE(exynos_drm_ipp_params_maps); i++) 323 if (map[i].id == id) 324 break; 325 if (i == ARRAY_SIZE(exynos_drm_ipp_params_maps) || 326 map[i].size > size) 327 return -EINVAL; 328 329 if (copy_from_user((void *)task + map[i].offset, params, 330 map[i].size)) 331 return -EFAULT; 332 333 params += map[i].size; 334 size -= map[i].size; 335 } 336 337 DRM_DEV_DEBUG_DRIVER(task->dev, 338 "Got task %pK configuration from userspace\n", 339 task); 340 return 0; 341 } 342 343 static int exynos_drm_ipp_task_setup_buffer(struct exynos_drm_ipp_buffer *buf, 344 struct drm_file *filp) 345 { 346 int ret = 0; 347 int i; 348 349 /* get GEM buffers and check their size */ 350 for (i = 0; i < buf->format->num_planes; i++) { 351 unsigned int height = (i == 0) ? buf->buf.height : 352 DIV_ROUND_UP(buf->buf.height, buf->format->vsub); 353 unsigned long size = height * buf->buf.pitch[i]; 354 struct exynos_drm_gem *gem = exynos_drm_gem_get(filp, 355 buf->buf.gem_id[i]); 356 if (!gem) { 357 ret = -ENOENT; 358 goto gem_free; 359 } 360 buf->exynos_gem[i] = gem; 361 362 if (size + buf->buf.offset[i] > buf->exynos_gem[i]->size) { 363 i++; 364 ret = -EINVAL; 365 goto gem_free; 366 } 367 buf->dma_addr[i] = buf->exynos_gem[i]->dma_addr + 368 buf->buf.offset[i]; 369 } 370 371 return 0; 372 gem_free: 373 while (i--) { 374 exynos_drm_gem_put(buf->exynos_gem[i]); 375 buf->exynos_gem[i] = NULL; 376 } 377 return ret; 378 } 379 380 static void exynos_drm_ipp_task_release_buf(struct exynos_drm_ipp_buffer *buf) 381 { 382 int i; 383 384 if (!buf->exynos_gem[0]) 385 return; 386 for (i = 0; i < buf->format->num_planes; i++) 387 exynos_drm_gem_put(buf->exynos_gem[i]); 388 } 389 390 static void exynos_drm_ipp_task_free(struct exynos_drm_ipp *ipp, 391 struct exynos_drm_ipp_task *task) 392 { 393 DRM_DEV_DEBUG_DRIVER(task->dev, "Freeing task %pK\n", task); 394 395 exynos_drm_ipp_task_release_buf(&task->src); 396 exynos_drm_ipp_task_release_buf(&task->dst); 397 if (task->event) 398 drm_event_cancel_free(ipp->drm_dev, &task->event->base); 399 kfree(task); 400 } 401 402 struct drm_ipp_limit { 403 struct drm_exynos_ipp_limit_val h; 404 struct drm_exynos_ipp_limit_val v; 405 }; 406 407 enum drm_ipp_size_id { 408 IPP_LIMIT_BUFFER, IPP_LIMIT_AREA, IPP_LIMIT_ROTATED, IPP_LIMIT_MAX 409 }; 410 411 static const enum drm_exynos_ipp_limit_type limit_id_fallback[IPP_LIMIT_MAX][4] = { 412 [IPP_LIMIT_BUFFER] = { DRM_EXYNOS_IPP_LIMIT_SIZE_BUFFER }, 413 [IPP_LIMIT_AREA] = { DRM_EXYNOS_IPP_LIMIT_SIZE_AREA, 414 DRM_EXYNOS_IPP_LIMIT_SIZE_BUFFER }, 415 [IPP_LIMIT_ROTATED] = { DRM_EXYNOS_IPP_LIMIT_SIZE_ROTATED, 416 DRM_EXYNOS_IPP_LIMIT_SIZE_AREA, 417 DRM_EXYNOS_IPP_LIMIT_SIZE_BUFFER }, 418 }; 419 420 static inline void __limit_set_val(unsigned int *ptr, unsigned int val) 421 { 422 if (!*ptr) 423 *ptr = val; 424 } 425 426 static void __get_size_limit(const struct drm_exynos_ipp_limit *limits, 427 unsigned int num_limits, enum drm_ipp_size_id id, 428 struct drm_ipp_limit *res) 429 { 430 const struct drm_exynos_ipp_limit *l = limits; 431 int i = 0; 432 433 memset(res, 0, sizeof(*res)); 434 for (i = 0; limit_id_fallback[id][i]; i++) 435 for (l = limits; l - limits < num_limits; l++) { 436 if (((l->type & DRM_EXYNOS_IPP_LIMIT_TYPE_MASK) != 437 DRM_EXYNOS_IPP_LIMIT_TYPE_SIZE) || 438 ((l->type & DRM_EXYNOS_IPP_LIMIT_SIZE_MASK) != 439 limit_id_fallback[id][i])) 440 continue; 441 __limit_set_val(&res->h.min, l->h.min); 442 __limit_set_val(&res->h.max, l->h.max); 443 __limit_set_val(&res->h.align, l->h.align); 444 __limit_set_val(&res->v.min, l->v.min); 445 __limit_set_val(&res->v.max, l->v.max); 446 __limit_set_val(&res->v.align, l->v.align); 447 } 448 } 449 450 static inline bool __align_check(unsigned int val, unsigned int align) 451 { 452 if (align && (val & (align - 1))) { 453 DRM_DEBUG_DRIVER("Value %d exceeds HW limits (align %d)\n", 454 val, align); 455 return false; 456 } 457 return true; 458 } 459 460 static inline bool __size_limit_check(unsigned int val, 461 struct drm_exynos_ipp_limit_val *l) 462 { 463 if ((l->min && val < l->min) || (l->max && val > l->max)) { 464 DRM_DEBUG_DRIVER("Value %d exceeds HW limits (min %d, max %d)\n", 465 val, l->min, l->max); 466 return false; 467 } 468 return __align_check(val, l->align); 469 } 470 471 static int exynos_drm_ipp_check_size_limits(struct exynos_drm_ipp_buffer *buf, 472 const struct drm_exynos_ipp_limit *limits, unsigned int num_limits, 473 bool rotate, bool swap) 474 { 475 enum drm_ipp_size_id id = rotate ? IPP_LIMIT_ROTATED : IPP_LIMIT_AREA; 476 struct drm_ipp_limit l; 477 struct drm_exynos_ipp_limit_val *lh = &l.h, *lv = &l.v; 478 int real_width = buf->buf.pitch[0] / buf->format->cpp[0]; 479 480 if (!limits) 481 return 0; 482 483 __get_size_limit(limits, num_limits, IPP_LIMIT_BUFFER, &l); 484 if (!__size_limit_check(real_width, &l.h) || 485 !__size_limit_check(buf->buf.height, &l.v)) 486 return -EINVAL; 487 488 if (swap) { 489 lv = &l.h; 490 lh = &l.v; 491 } 492 __get_size_limit(limits, num_limits, id, &l); 493 if (!__size_limit_check(buf->rect.w, lh) || 494 !__align_check(buf->rect.x, lh->align) || 495 !__size_limit_check(buf->rect.h, lv) || 496 !__align_check(buf->rect.y, lv->align)) 497 return -EINVAL; 498 499 return 0; 500 } 501 502 static inline bool __scale_limit_check(unsigned int src, unsigned int dst, 503 unsigned int min, unsigned int max) 504 { 505 if ((max && (dst << 16) > src * max) || 506 (min && (dst << 16) < src * min)) { 507 DRM_DEBUG_DRIVER("Scale from %d to %d exceeds HW limits (ratio min %d.%05d, max %d.%05d)\n", 508 src, dst, 509 min >> 16, 100000 * (min & 0xffff) / (1 << 16), 510 max >> 16, 100000 * (max & 0xffff) / (1 << 16)); 511 return false; 512 } 513 return true; 514 } 515 516 static int exynos_drm_ipp_check_scale_limits( 517 struct drm_exynos_ipp_task_rect *src, 518 struct drm_exynos_ipp_task_rect *dst, 519 const struct drm_exynos_ipp_limit *limits, 520 unsigned int num_limits, bool swap) 521 { 522 const struct drm_exynos_ipp_limit_val *lh, *lv; 523 int dw, dh; 524 525 for (; num_limits; limits++, num_limits--) 526 if ((limits->type & DRM_EXYNOS_IPP_LIMIT_TYPE_MASK) == 527 DRM_EXYNOS_IPP_LIMIT_TYPE_SCALE) 528 break; 529 if (!num_limits) 530 return 0; 531 532 lh = (!swap) ? &limits->h : &limits->v; 533 lv = (!swap) ? &limits->v : &limits->h; 534 dw = (!swap) ? dst->w : dst->h; 535 dh = (!swap) ? dst->h : dst->w; 536 537 if (!__scale_limit_check(src->w, dw, lh->min, lh->max) || 538 !__scale_limit_check(src->h, dh, lv->min, lv->max)) 539 return -EINVAL; 540 541 return 0; 542 } 543 544 static int exynos_drm_ipp_check_format(struct exynos_drm_ipp_task *task, 545 struct exynos_drm_ipp_buffer *buf, 546 struct exynos_drm_ipp_buffer *src, 547 struct exynos_drm_ipp_buffer *dst, 548 bool rotate, bool swap) 549 { 550 const struct exynos_drm_ipp_formats *fmt; 551 int ret, i; 552 553 fmt = __ipp_format_get(task->ipp, buf->buf.fourcc, buf->buf.modifier, 554 buf == src ? DRM_EXYNOS_IPP_FORMAT_SOURCE : 555 DRM_EXYNOS_IPP_FORMAT_DESTINATION); 556 if (!fmt) { 557 DRM_DEV_DEBUG_DRIVER(task->dev, 558 "Task %pK: %s format not supported\n", 559 task, buf == src ? "src" : "dst"); 560 return -EINVAL; 561 } 562 563 /* basic checks */ 564 if (buf->buf.width == 0 || buf->buf.height == 0) 565 return -EINVAL; 566 567 buf->format = drm_format_info(buf->buf.fourcc); 568 for (i = 0; i < buf->format->num_planes; i++) { 569 unsigned int width = (i == 0) ? buf->buf.width : 570 DIV_ROUND_UP(buf->buf.width, buf->format->hsub); 571 572 if (buf->buf.pitch[i] == 0) 573 buf->buf.pitch[i] = width * buf->format->cpp[i]; 574 if (buf->buf.pitch[i] < width * buf->format->cpp[i]) 575 return -EINVAL; 576 if (!buf->buf.gem_id[i]) 577 return -ENOENT; 578 } 579 580 /* pitch for additional planes must match */ 581 if (buf->format->num_planes > 2 && 582 buf->buf.pitch[1] != buf->buf.pitch[2]) 583 return -EINVAL; 584 585 /* check driver limits */ 586 ret = exynos_drm_ipp_check_size_limits(buf, fmt->limits, 587 fmt->num_limits, 588 rotate, 589 buf == dst ? swap : false); 590 if (ret) 591 return ret; 592 ret = exynos_drm_ipp_check_scale_limits(&src->rect, &dst->rect, 593 fmt->limits, 594 fmt->num_limits, swap); 595 return ret; 596 } 597 598 static int exynos_drm_ipp_task_check(struct exynos_drm_ipp_task *task) 599 { 600 struct exynos_drm_ipp *ipp = task->ipp; 601 struct exynos_drm_ipp_buffer *src = &task->src, *dst = &task->dst; 602 unsigned int rotation = task->transform.rotation; 603 int ret = 0; 604 bool swap = drm_rotation_90_or_270(rotation); 605 bool rotate = (rotation != DRM_MODE_ROTATE_0); 606 bool scale = false; 607 608 DRM_DEV_DEBUG_DRIVER(task->dev, "Checking task %pK\n", task); 609 610 if (src->rect.w == UINT_MAX) 611 src->rect.w = src->buf.width; 612 if (src->rect.h == UINT_MAX) 613 src->rect.h = src->buf.height; 614 if (dst->rect.w == UINT_MAX) 615 dst->rect.w = dst->buf.width; 616 if (dst->rect.h == UINT_MAX) 617 dst->rect.h = dst->buf.height; 618 619 if (src->rect.x + src->rect.w > (src->buf.width) || 620 src->rect.y + src->rect.h > (src->buf.height) || 621 dst->rect.x + dst->rect.w > (dst->buf.width) || 622 dst->rect.y + dst->rect.h > (dst->buf.height)) { 623 DRM_DEV_DEBUG_DRIVER(task->dev, 624 "Task %pK: defined area is outside provided buffers\n", 625 task); 626 return -EINVAL; 627 } 628 629 if ((!swap && (src->rect.w != dst->rect.w || 630 src->rect.h != dst->rect.h)) || 631 (swap && (src->rect.w != dst->rect.h || 632 src->rect.h != dst->rect.w))) 633 scale = true; 634 635 if ((!(ipp->capabilities & DRM_EXYNOS_IPP_CAP_CROP) && 636 (src->rect.x || src->rect.y || dst->rect.x || dst->rect.y)) || 637 (!(ipp->capabilities & DRM_EXYNOS_IPP_CAP_ROTATE) && rotate) || 638 (!(ipp->capabilities & DRM_EXYNOS_IPP_CAP_SCALE) && scale) || 639 (!(ipp->capabilities & DRM_EXYNOS_IPP_CAP_CONVERT) && 640 src->buf.fourcc != dst->buf.fourcc)) { 641 DRM_DEV_DEBUG_DRIVER(task->dev, "Task %pK: hw capabilities exceeded\n", 642 task); 643 return -EINVAL; 644 } 645 646 ret = exynos_drm_ipp_check_format(task, src, src, dst, rotate, swap); 647 if (ret) 648 return ret; 649 650 ret = exynos_drm_ipp_check_format(task, dst, src, dst, false, swap); 651 if (ret) 652 return ret; 653 654 DRM_DEV_DEBUG_DRIVER(ipp->dev, "Task %pK: all checks done.\n", 655 task); 656 657 return ret; 658 } 659 660 static int exynos_drm_ipp_task_setup_buffers(struct exynos_drm_ipp_task *task, 661 struct drm_file *filp) 662 { 663 struct exynos_drm_ipp_buffer *src = &task->src, *dst = &task->dst; 664 int ret = 0; 665 666 DRM_DEV_DEBUG_DRIVER(task->dev, "Setting buffer for task %pK\n", 667 task); 668 669 ret = exynos_drm_ipp_task_setup_buffer(src, filp); 670 if (ret) { 671 DRM_DEV_DEBUG_DRIVER(task->dev, 672 "Task %pK: src buffer setup failed\n", 673 task); 674 return ret; 675 } 676 ret = exynos_drm_ipp_task_setup_buffer(dst, filp); 677 if (ret) { 678 DRM_DEV_DEBUG_DRIVER(task->dev, 679 "Task %pK: dst buffer setup failed\n", 680 task); 681 return ret; 682 } 683 684 DRM_DEV_DEBUG_DRIVER(task->dev, "Task %pK: buffers prepared.\n", 685 task); 686 687 return ret; 688 } 689 690 691 static int exynos_drm_ipp_event_create(struct exynos_drm_ipp_task *task, 692 struct drm_file *file_priv, uint64_t user_data) 693 { 694 struct drm_pending_exynos_ipp_event *e = NULL; 695 int ret; 696 697 e = kzalloc(sizeof(*e), GFP_KERNEL); 698 if (!e) 699 return -ENOMEM; 700 701 e->event.base.type = DRM_EXYNOS_IPP_EVENT; 702 e->event.base.length = sizeof(e->event); 703 e->event.user_data = user_data; 704 705 ret = drm_event_reserve_init(task->ipp->drm_dev, file_priv, &e->base, 706 &e->event.base); 707 if (ret) 708 goto free; 709 710 task->event = e; 711 return 0; 712 free: 713 kfree(e); 714 return ret; 715 } 716 717 static void exynos_drm_ipp_event_send(struct exynos_drm_ipp_task *task) 718 { 719 struct timespec64 now; 720 721 ktime_get_ts64(&now); 722 task->event->event.tv_sec = now.tv_sec; 723 task->event->event.tv_usec = now.tv_nsec / NSEC_PER_USEC; 724 task->event->event.sequence = atomic_inc_return(&task->ipp->sequence); 725 726 drm_send_event(task->ipp->drm_dev, &task->event->base); 727 } 728 729 static int exynos_drm_ipp_task_cleanup(struct exynos_drm_ipp_task *task) 730 { 731 int ret = task->ret; 732 733 if (ret == 0 && task->event) { 734 exynos_drm_ipp_event_send(task); 735 /* ensure event won't be canceled on task free */ 736 task->event = NULL; 737 } 738 739 exynos_drm_ipp_task_free(task->ipp, task); 740 return ret; 741 } 742 743 static void exynos_drm_ipp_cleanup_work(struct work_struct *work) 744 { 745 struct exynos_drm_ipp_task *task = container_of(work, 746 struct exynos_drm_ipp_task, cleanup_work); 747 748 exynos_drm_ipp_task_cleanup(task); 749 } 750 751 static void exynos_drm_ipp_next_task(struct exynos_drm_ipp *ipp); 752 753 /** 754 * exynos_drm_ipp_task_done - finish given task and set return code 755 * @task: ipp task to finish 756 * @ret: error code or 0 if operation has been performed successfully 757 */ 758 void exynos_drm_ipp_task_done(struct exynos_drm_ipp_task *task, int ret) 759 { 760 struct exynos_drm_ipp *ipp = task->ipp; 761 unsigned long flags; 762 763 DRM_DEV_DEBUG_DRIVER(task->dev, "ipp: %d, task %pK done: %d\n", 764 ipp->id, task, ret); 765 766 spin_lock_irqsave(&ipp->lock, flags); 767 if (ipp->task == task) 768 ipp->task = NULL; 769 task->flags |= DRM_EXYNOS_IPP_TASK_DONE; 770 task->ret = ret; 771 spin_unlock_irqrestore(&ipp->lock, flags); 772 773 exynos_drm_ipp_next_task(ipp); 774 wake_up(&ipp->done_wq); 775 776 if (task->flags & DRM_EXYNOS_IPP_TASK_ASYNC) { 777 INIT_WORK(&task->cleanup_work, exynos_drm_ipp_cleanup_work); 778 schedule_work(&task->cleanup_work); 779 } 780 } 781 782 static void exynos_drm_ipp_next_task(struct exynos_drm_ipp *ipp) 783 { 784 struct exynos_drm_ipp_task *task; 785 unsigned long flags; 786 int ret; 787 788 DRM_DEV_DEBUG_DRIVER(ipp->dev, "ipp: %d, try to run new task\n", 789 ipp->id); 790 791 spin_lock_irqsave(&ipp->lock, flags); 792 793 if (ipp->task || list_empty(&ipp->todo_list)) { 794 spin_unlock_irqrestore(&ipp->lock, flags); 795 return; 796 } 797 798 task = list_first_entry(&ipp->todo_list, struct exynos_drm_ipp_task, 799 head); 800 list_del_init(&task->head); 801 ipp->task = task; 802 803 spin_unlock_irqrestore(&ipp->lock, flags); 804 805 DRM_DEV_DEBUG_DRIVER(ipp->dev, 806 "ipp: %d, selected task %pK to run\n", ipp->id, 807 task); 808 809 ret = ipp->funcs->commit(ipp, task); 810 if (ret) 811 exynos_drm_ipp_task_done(task, ret); 812 } 813 814 static void exynos_drm_ipp_schedule_task(struct exynos_drm_ipp *ipp, 815 struct exynos_drm_ipp_task *task) 816 { 817 unsigned long flags; 818 819 spin_lock_irqsave(&ipp->lock, flags); 820 list_add(&task->head, &ipp->todo_list); 821 spin_unlock_irqrestore(&ipp->lock, flags); 822 823 exynos_drm_ipp_next_task(ipp); 824 } 825 826 static void exynos_drm_ipp_task_abort(struct exynos_drm_ipp *ipp, 827 struct exynos_drm_ipp_task *task) 828 { 829 unsigned long flags; 830 831 spin_lock_irqsave(&ipp->lock, flags); 832 if (task->flags & DRM_EXYNOS_IPP_TASK_DONE) { 833 /* already completed task */ 834 exynos_drm_ipp_task_cleanup(task); 835 } else if (ipp->task != task) { 836 /* task has not been scheduled for execution yet */ 837 list_del_init(&task->head); 838 exynos_drm_ipp_task_cleanup(task); 839 } else { 840 /* 841 * currently processed task, call abort() and perform 842 * cleanup with async worker 843 */ 844 task->flags |= DRM_EXYNOS_IPP_TASK_ASYNC; 845 spin_unlock_irqrestore(&ipp->lock, flags); 846 if (ipp->funcs->abort) 847 ipp->funcs->abort(ipp, task); 848 return; 849 } 850 spin_unlock_irqrestore(&ipp->lock, flags); 851 } 852 853 /** 854 * exynos_drm_ipp_commit_ioctl - perform image processing operation 855 * @dev: DRM device 856 * @data: ioctl data 857 * @file_priv: DRM file info 858 * 859 * Construct a ipp task from the set of properties provided from the user 860 * and try to schedule it to framebuffer processor hardware. 861 * 862 * Called by the user via ioctl. 863 * 864 * Returns: 865 * Zero on success, negative errno on failure. 866 */ 867 int exynos_drm_ipp_commit_ioctl(struct drm_device *dev, void *data, 868 struct drm_file *file_priv) 869 { 870 struct drm_exynos_ioctl_ipp_commit *arg = data; 871 struct exynos_drm_ipp *ipp; 872 struct exynos_drm_ipp_task *task; 873 int ret = 0; 874 875 if ((arg->flags & ~DRM_EXYNOS_IPP_FLAGS) || arg->reserved) 876 return -EINVAL; 877 878 /* can't test and expect an event at the same time */ 879 if ((arg->flags & DRM_EXYNOS_IPP_FLAG_TEST_ONLY) && 880 (arg->flags & DRM_EXYNOS_IPP_FLAG_EVENT)) 881 return -EINVAL; 882 883 ipp = __ipp_get(arg->ipp_id); 884 if (!ipp) 885 return -ENOENT; 886 887 task = exynos_drm_ipp_task_alloc(ipp); 888 if (!task) 889 return -ENOMEM; 890 891 ret = exynos_drm_ipp_task_set(task, arg); 892 if (ret) 893 goto free; 894 895 ret = exynos_drm_ipp_task_check(task); 896 if (ret) 897 goto free; 898 899 ret = exynos_drm_ipp_task_setup_buffers(task, file_priv); 900 if (ret || arg->flags & DRM_EXYNOS_IPP_FLAG_TEST_ONLY) 901 goto free; 902 903 if (arg->flags & DRM_EXYNOS_IPP_FLAG_EVENT) { 904 ret = exynos_drm_ipp_event_create(task, file_priv, 905 arg->user_data); 906 if (ret) 907 goto free; 908 } 909 910 /* 911 * Queue task for processing on the hardware. task object will be 912 * then freed after exynos_drm_ipp_task_done() 913 */ 914 if (arg->flags & DRM_EXYNOS_IPP_FLAG_NONBLOCK) { 915 DRM_DEV_DEBUG_DRIVER(ipp->dev, 916 "ipp: %d, nonblocking processing task %pK\n", 917 ipp->id, task); 918 919 task->flags |= DRM_EXYNOS_IPP_TASK_ASYNC; 920 exynos_drm_ipp_schedule_task(task->ipp, task); 921 ret = 0; 922 } else { 923 DRM_DEV_DEBUG_DRIVER(ipp->dev, "ipp: %d, processing task %pK\n", 924 ipp->id, task); 925 exynos_drm_ipp_schedule_task(ipp, task); 926 ret = wait_event_interruptible(ipp->done_wq, 927 task->flags & DRM_EXYNOS_IPP_TASK_DONE); 928 if (ret) 929 exynos_drm_ipp_task_abort(ipp, task); 930 else 931 ret = exynos_drm_ipp_task_cleanup(task); 932 } 933 return ret; 934 free: 935 exynos_drm_ipp_task_free(ipp, task); 936 937 return ret; 938 } 939