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