1 /* 2 * Copyright (C) 2012 Samsung Electronics Co.Ltd 3 * Authors: 4 * Eunchul Kim <chulspro.kim@samsung.com> 5 * Jinyoung Jeon <jy0.jeon@samsung.com> 6 * Sangmin Lee <lsmin.lee@samsung.com> 7 * 8 * This program is free software; you can redistribute it and/or modify it 9 * under the terms of the GNU General Public License as published by the 10 * Free Software Foundation; either version 2 of the License, or (at your 11 * option) any later version. 12 * 13 */ 14 #include <linux/kernel.h> 15 #include <linux/platform_device.h> 16 #include <linux/types.h> 17 #include <linux/clk.h> 18 #include <linux/pm_runtime.h> 19 20 #include <drm/drmP.h> 21 #include <drm/exynos_drm.h> 22 #include "exynos_drm_drv.h" 23 #include "exynos_drm_gem.h" 24 #include "exynos_drm_ipp.h" 25 #include "exynos_drm_iommu.h" 26 27 /* 28 * IPP stands for Image Post Processing and 29 * supports image scaler/rotator and input/output DMA operations. 30 * using FIMC, GSC, Rotator, so on. 31 * IPP is integration device driver of same attribute h/w 32 */ 33 34 /* 35 * TODO 36 * 1. expand command control id. 37 * 2. integrate property and config. 38 * 3. removed send_event id check routine. 39 * 4. compare send_event id if needed. 40 * 5. free subdrv_remove notifier callback list if needed. 41 * 6. need to check subdrv_open about multi-open. 42 * 7. need to power_on implement power and sysmmu ctrl. 43 */ 44 45 #define get_ipp_context(dev) platform_get_drvdata(to_platform_device(dev)) 46 #define ipp_is_m2m_cmd(c) (c == IPP_CMD_M2M) 47 48 /* 49 * A structure of event. 50 * 51 * @base: base of event. 52 * @event: ipp event. 53 */ 54 struct drm_exynos_ipp_send_event { 55 struct drm_pending_event base; 56 struct drm_exynos_ipp_event event; 57 }; 58 59 /* 60 * A structure of memory node. 61 * 62 * @list: list head to memory queue information. 63 * @ops_id: id of operations. 64 * @prop_id: id of property. 65 * @buf_id: id of buffer. 66 * @buf_info: gem objects and dma address, size. 67 * @filp: a pointer to drm_file. 68 */ 69 struct drm_exynos_ipp_mem_node { 70 struct list_head list; 71 enum drm_exynos_ops_id ops_id; 72 u32 prop_id; 73 u32 buf_id; 74 struct drm_exynos_ipp_buf_info buf_info; 75 }; 76 77 /* 78 * A structure of ipp context. 79 * 80 * @subdrv: prepare initialization using subdrv. 81 * @ipp_lock: lock for synchronization of access to ipp_idr. 82 * @prop_lock: lock for synchronization of access to prop_idr. 83 * @ipp_idr: ipp driver idr. 84 * @prop_idr: property idr. 85 * @event_workq: event work queue. 86 * @cmd_workq: command work queue. 87 */ 88 struct ipp_context { 89 struct exynos_drm_subdrv subdrv; 90 struct mutex ipp_lock; 91 struct mutex prop_lock; 92 struct idr ipp_idr; 93 struct idr prop_idr; 94 struct workqueue_struct *event_workq; 95 struct workqueue_struct *cmd_workq; 96 }; 97 98 static LIST_HEAD(exynos_drm_ippdrv_list); 99 static DEFINE_MUTEX(exynos_drm_ippdrv_lock); 100 static BLOCKING_NOTIFIER_HEAD(exynos_drm_ippnb_list); 101 102 int exynos_drm_ippdrv_register(struct exynos_drm_ippdrv *ippdrv) 103 { 104 mutex_lock(&exynos_drm_ippdrv_lock); 105 list_add_tail(&ippdrv->drv_list, &exynos_drm_ippdrv_list); 106 mutex_unlock(&exynos_drm_ippdrv_lock); 107 108 return 0; 109 } 110 111 int exynos_drm_ippdrv_unregister(struct exynos_drm_ippdrv *ippdrv) 112 { 113 mutex_lock(&exynos_drm_ippdrv_lock); 114 list_del(&ippdrv->drv_list); 115 mutex_unlock(&exynos_drm_ippdrv_lock); 116 117 return 0; 118 } 119 120 static int ipp_create_id(struct idr *id_idr, struct mutex *lock, void *obj) 121 { 122 int ret; 123 124 mutex_lock(lock); 125 ret = idr_alloc(id_idr, obj, 1, 0, GFP_KERNEL); 126 mutex_unlock(lock); 127 128 return ret; 129 } 130 131 static void ipp_remove_id(struct idr *id_idr, struct mutex *lock, u32 id) 132 { 133 mutex_lock(lock); 134 idr_remove(id_idr, id); 135 mutex_unlock(lock); 136 } 137 138 static void *ipp_find_obj(struct idr *id_idr, struct mutex *lock, u32 id) 139 { 140 void *obj; 141 142 mutex_lock(lock); 143 obj = idr_find(id_idr, id); 144 mutex_unlock(lock); 145 146 return obj; 147 } 148 149 static int ipp_check_driver(struct exynos_drm_ippdrv *ippdrv, 150 struct drm_exynos_ipp_property *property) 151 { 152 if (ippdrv->dedicated || (!ipp_is_m2m_cmd(property->cmd) && 153 !pm_runtime_suspended(ippdrv->dev))) 154 return -EBUSY; 155 156 if (ippdrv->check_property && 157 ippdrv->check_property(ippdrv->dev, property)) 158 return -EINVAL; 159 160 return 0; 161 } 162 163 static struct exynos_drm_ippdrv *ipp_find_driver(struct ipp_context *ctx, 164 struct drm_exynos_ipp_property *property) 165 { 166 struct exynos_drm_ippdrv *ippdrv; 167 u32 ipp_id = property->ipp_id; 168 int ret; 169 170 if (ipp_id) { 171 ippdrv = ipp_find_obj(&ctx->ipp_idr, &ctx->ipp_lock, ipp_id); 172 if (!ippdrv) { 173 DRM_DEBUG("ipp%d driver not found\n", ipp_id); 174 return ERR_PTR(-ENODEV); 175 } 176 177 ret = ipp_check_driver(ippdrv, property); 178 if (ret < 0) { 179 DRM_DEBUG("ipp%d driver check error %d\n", ipp_id, ret); 180 return ERR_PTR(ret); 181 } 182 183 return ippdrv; 184 } else { 185 list_for_each_entry(ippdrv, &exynos_drm_ippdrv_list, drv_list) { 186 ret = ipp_check_driver(ippdrv, property); 187 if (ret == 0) 188 return ippdrv; 189 } 190 191 DRM_DEBUG("cannot find driver suitable for given property.\n"); 192 } 193 194 return ERR_PTR(-ENODEV); 195 } 196 197 static struct exynos_drm_ippdrv *ipp_find_drv_by_handle(u32 prop_id) 198 { 199 struct exynos_drm_ippdrv *ippdrv; 200 struct drm_exynos_ipp_cmd_node *c_node; 201 int count = 0; 202 203 DRM_DEBUG_KMS("prop_id[%d]\n", prop_id); 204 205 /* 206 * This case is search ipp driver by prop_id handle. 207 * sometimes, ipp subsystem find driver by prop_id. 208 * e.g PAUSE state, queue buf, command control. 209 */ 210 list_for_each_entry(ippdrv, &exynos_drm_ippdrv_list, drv_list) { 211 DRM_DEBUG_KMS("count[%d]ippdrv[%p]\n", count++, ippdrv); 212 213 mutex_lock(&ippdrv->cmd_lock); 214 list_for_each_entry(c_node, &ippdrv->cmd_list, list) { 215 if (c_node->property.prop_id == prop_id) { 216 mutex_unlock(&ippdrv->cmd_lock); 217 return ippdrv; 218 } 219 } 220 mutex_unlock(&ippdrv->cmd_lock); 221 } 222 223 return ERR_PTR(-ENODEV); 224 } 225 226 int exynos_drm_ipp_get_property(struct drm_device *drm_dev, void *data, 227 struct drm_file *file) 228 { 229 struct drm_exynos_file_private *file_priv = file->driver_priv; 230 struct device *dev = file_priv->ipp_dev; 231 struct ipp_context *ctx = get_ipp_context(dev); 232 struct drm_exynos_ipp_prop_list *prop_list = data; 233 struct exynos_drm_ippdrv *ippdrv; 234 int count = 0; 235 236 if (!ctx) { 237 DRM_ERROR("invalid context.\n"); 238 return -EINVAL; 239 } 240 241 if (!prop_list) { 242 DRM_ERROR("invalid property parameter.\n"); 243 return -EINVAL; 244 } 245 246 DRM_DEBUG_KMS("ipp_id[%d]\n", prop_list->ipp_id); 247 248 if (!prop_list->ipp_id) { 249 list_for_each_entry(ippdrv, &exynos_drm_ippdrv_list, drv_list) 250 count++; 251 252 /* 253 * Supports ippdrv list count for user application. 254 * First step user application getting ippdrv count. 255 * and second step getting ippdrv capability using ipp_id. 256 */ 257 prop_list->count = count; 258 } else { 259 /* 260 * Getting ippdrv capability by ipp_id. 261 * some device not supported wb, output interface. 262 * so, user application detect correct ipp driver 263 * using this ioctl. 264 */ 265 ippdrv = ipp_find_obj(&ctx->ipp_idr, &ctx->ipp_lock, 266 prop_list->ipp_id); 267 if (!ippdrv) { 268 DRM_ERROR("not found ipp%d driver.\n", 269 prop_list->ipp_id); 270 return -ENODEV; 271 } 272 273 *prop_list = ippdrv->prop_list; 274 } 275 276 return 0; 277 } 278 279 static void ipp_print_property(struct drm_exynos_ipp_property *property, 280 int idx) 281 { 282 struct drm_exynos_ipp_config *config = &property->config[idx]; 283 struct drm_exynos_pos *pos = &config->pos; 284 struct drm_exynos_sz *sz = &config->sz; 285 286 DRM_DEBUG_KMS("prop_id[%d]ops[%s]fmt[0x%x]\n", 287 property->prop_id, idx ? "dst" : "src", config->fmt); 288 289 DRM_DEBUG_KMS("pos[%d %d %d %d]sz[%d %d]f[%d]r[%d]\n", 290 pos->x, pos->y, pos->w, pos->h, 291 sz->hsize, sz->vsize, config->flip, config->degree); 292 } 293 294 static struct drm_exynos_ipp_cmd_work *ipp_create_cmd_work(void) 295 { 296 struct drm_exynos_ipp_cmd_work *cmd_work; 297 298 cmd_work = kzalloc(sizeof(*cmd_work), GFP_KERNEL); 299 if (!cmd_work) 300 return ERR_PTR(-ENOMEM); 301 302 INIT_WORK((struct work_struct *)cmd_work, ipp_sched_cmd); 303 304 return cmd_work; 305 } 306 307 static struct drm_exynos_ipp_event_work *ipp_create_event_work(void) 308 { 309 struct drm_exynos_ipp_event_work *event_work; 310 311 event_work = kzalloc(sizeof(*event_work), GFP_KERNEL); 312 if (!event_work) 313 return ERR_PTR(-ENOMEM); 314 315 INIT_WORK(&event_work->work, ipp_sched_event); 316 317 return event_work; 318 } 319 320 int exynos_drm_ipp_set_property(struct drm_device *drm_dev, void *data, 321 struct drm_file *file) 322 { 323 struct drm_exynos_file_private *file_priv = file->driver_priv; 324 struct device *dev = file_priv->ipp_dev; 325 struct ipp_context *ctx = get_ipp_context(dev); 326 struct drm_exynos_ipp_property *property = data; 327 struct exynos_drm_ippdrv *ippdrv; 328 struct drm_exynos_ipp_cmd_node *c_node; 329 u32 prop_id; 330 int ret, i; 331 332 if (!ctx) { 333 DRM_ERROR("invalid context.\n"); 334 return -EINVAL; 335 } 336 337 if (!property) { 338 DRM_ERROR("invalid property parameter.\n"); 339 return -EINVAL; 340 } 341 342 prop_id = property->prop_id; 343 344 /* 345 * This is log print for user application property. 346 * user application set various property. 347 */ 348 for_each_ipp_ops(i) 349 ipp_print_property(property, i); 350 351 /* 352 * In case prop_id is not zero try to set existing property. 353 */ 354 if (prop_id) { 355 c_node = ipp_find_obj(&ctx->prop_idr, &ctx->prop_lock, prop_id); 356 357 if (!c_node || c_node->filp != file) { 358 DRM_DEBUG_KMS("prop_id[%d] not found\n", prop_id); 359 return -EINVAL; 360 } 361 362 if (c_node->state != IPP_STATE_STOP) { 363 DRM_DEBUG_KMS("prop_id[%d] not stopped\n", prop_id); 364 return -EINVAL; 365 } 366 367 c_node->property = *property; 368 369 return 0; 370 } 371 372 /* find ipp driver using ipp id */ 373 ippdrv = ipp_find_driver(ctx, property); 374 if (IS_ERR(ippdrv)) { 375 DRM_ERROR("failed to get ipp driver.\n"); 376 return -EINVAL; 377 } 378 379 /* allocate command node */ 380 c_node = kzalloc(sizeof(*c_node), GFP_KERNEL); 381 if (!c_node) 382 return -ENOMEM; 383 384 ret = ipp_create_id(&ctx->prop_idr, &ctx->prop_lock, c_node); 385 if (ret < 0) { 386 DRM_ERROR("failed to create id.\n"); 387 goto err_clear; 388 } 389 property->prop_id = ret; 390 391 DRM_DEBUG_KMS("created prop_id[%d]cmd[%d]ippdrv[%p]\n", 392 property->prop_id, property->cmd, ippdrv); 393 394 /* stored property information and ippdrv in private data */ 395 c_node->property = *property; 396 c_node->state = IPP_STATE_IDLE; 397 c_node->filp = file; 398 399 c_node->start_work = ipp_create_cmd_work(); 400 if (IS_ERR(c_node->start_work)) { 401 DRM_ERROR("failed to create start work.\n"); 402 ret = PTR_ERR(c_node->start_work); 403 goto err_remove_id; 404 } 405 406 c_node->stop_work = ipp_create_cmd_work(); 407 if (IS_ERR(c_node->stop_work)) { 408 DRM_ERROR("failed to create stop work.\n"); 409 ret = PTR_ERR(c_node->stop_work); 410 goto err_free_start; 411 } 412 413 c_node->event_work = ipp_create_event_work(); 414 if (IS_ERR(c_node->event_work)) { 415 DRM_ERROR("failed to create event work.\n"); 416 ret = PTR_ERR(c_node->event_work); 417 goto err_free_stop; 418 } 419 420 mutex_init(&c_node->lock); 421 mutex_init(&c_node->mem_lock); 422 mutex_init(&c_node->event_lock); 423 424 init_completion(&c_node->start_complete); 425 init_completion(&c_node->stop_complete); 426 427 for_each_ipp_ops(i) 428 INIT_LIST_HEAD(&c_node->mem_list[i]); 429 430 INIT_LIST_HEAD(&c_node->event_list); 431 mutex_lock(&ippdrv->cmd_lock); 432 list_add_tail(&c_node->list, &ippdrv->cmd_list); 433 mutex_unlock(&ippdrv->cmd_lock); 434 435 /* make dedicated state without m2m */ 436 if (!ipp_is_m2m_cmd(property->cmd)) 437 ippdrv->dedicated = true; 438 439 return 0; 440 441 err_free_stop: 442 kfree(c_node->stop_work); 443 err_free_start: 444 kfree(c_node->start_work); 445 err_remove_id: 446 ipp_remove_id(&ctx->prop_idr, &ctx->prop_lock, property->prop_id); 447 err_clear: 448 kfree(c_node); 449 return ret; 450 } 451 452 static int ipp_validate_mem_node(struct drm_device *drm_dev, 453 struct drm_exynos_ipp_mem_node *m_node, 454 struct drm_exynos_ipp_cmd_node *c_node) 455 { 456 struct drm_exynos_ipp_config *ipp_cfg; 457 unsigned int num_plane; 458 unsigned long size, buf_size = 0, plane_size, img_size = 0; 459 unsigned int bpp, width, height; 460 int i; 461 462 ipp_cfg = &c_node->property.config[m_node->ops_id]; 463 num_plane = drm_format_num_planes(ipp_cfg->fmt); 464 465 /** 466 * This is a rather simplified validation of a memory node. 467 * It basically verifies provided gem object handles 468 * and the buffer sizes with respect to current configuration. 469 * This is not the best that can be done 470 * but it seems more than enough 471 */ 472 for (i = 0; i < num_plane; ++i) { 473 width = ipp_cfg->sz.hsize; 474 height = ipp_cfg->sz.vsize; 475 bpp = drm_format_plane_cpp(ipp_cfg->fmt, i); 476 477 /* 478 * The result of drm_format_plane_cpp() for chroma planes must 479 * be used with drm_format_xxxx_chroma_subsampling() for 480 * correct result. 481 */ 482 if (i > 0) { 483 width /= drm_format_horz_chroma_subsampling( 484 ipp_cfg->fmt); 485 height /= drm_format_vert_chroma_subsampling( 486 ipp_cfg->fmt); 487 } 488 plane_size = width * height * bpp; 489 img_size += plane_size; 490 491 if (m_node->buf_info.handles[i]) { 492 size = exynos_drm_gem_get_size(drm_dev, 493 m_node->buf_info.handles[i], 494 c_node->filp); 495 if (plane_size > size) { 496 DRM_ERROR( 497 "buffer %d is smaller than required\n", 498 i); 499 return -EINVAL; 500 } 501 502 buf_size += size; 503 } 504 } 505 506 if (buf_size < img_size) { 507 DRM_ERROR("size of buffers(%lu) is smaller than image(%lu)\n", 508 buf_size, img_size); 509 return -EINVAL; 510 } 511 512 return 0; 513 } 514 515 static int ipp_put_mem_node(struct drm_device *drm_dev, 516 struct drm_exynos_ipp_cmd_node *c_node, 517 struct drm_exynos_ipp_mem_node *m_node) 518 { 519 int i; 520 521 DRM_DEBUG_KMS("node[%p]\n", m_node); 522 523 if (!m_node) { 524 DRM_ERROR("invalid dequeue node.\n"); 525 return -EFAULT; 526 } 527 528 DRM_DEBUG_KMS("ops_id[%d]\n", m_node->ops_id); 529 530 /* put gem buffer */ 531 for_each_ipp_planar(i) { 532 unsigned long handle = m_node->buf_info.handles[i]; 533 if (handle) 534 exynos_drm_gem_put_dma_addr(drm_dev, handle, 535 c_node->filp); 536 } 537 538 list_del(&m_node->list); 539 kfree(m_node); 540 541 return 0; 542 } 543 544 static struct drm_exynos_ipp_mem_node 545 *ipp_get_mem_node(struct drm_device *drm_dev, 546 struct drm_exynos_ipp_cmd_node *c_node, 547 struct drm_exynos_ipp_queue_buf *qbuf) 548 { 549 struct drm_exynos_ipp_mem_node *m_node; 550 struct drm_exynos_ipp_buf_info *buf_info; 551 int i; 552 553 m_node = kzalloc(sizeof(*m_node), GFP_KERNEL); 554 if (!m_node) 555 return ERR_PTR(-ENOMEM); 556 557 buf_info = &m_node->buf_info; 558 559 /* operations, buffer id */ 560 m_node->ops_id = qbuf->ops_id; 561 m_node->prop_id = qbuf->prop_id; 562 m_node->buf_id = qbuf->buf_id; 563 INIT_LIST_HEAD(&m_node->list); 564 565 DRM_DEBUG_KMS("m_node[%p]ops_id[%d]\n", m_node, qbuf->ops_id); 566 DRM_DEBUG_KMS("prop_id[%d]buf_id[%d]\n", qbuf->prop_id, m_node->buf_id); 567 568 for_each_ipp_planar(i) { 569 DRM_DEBUG_KMS("i[%d]handle[0x%x]\n", i, qbuf->handle[i]); 570 571 /* get dma address by handle */ 572 if (qbuf->handle[i]) { 573 dma_addr_t *addr; 574 575 addr = exynos_drm_gem_get_dma_addr(drm_dev, 576 qbuf->handle[i], c_node->filp); 577 if (IS_ERR(addr)) { 578 DRM_ERROR("failed to get addr.\n"); 579 ipp_put_mem_node(drm_dev, c_node, m_node); 580 return ERR_PTR(-EFAULT); 581 } 582 583 buf_info->handles[i] = qbuf->handle[i]; 584 buf_info->base[i] = *addr; 585 DRM_DEBUG_KMS("i[%d]base[%pad]hd[0x%lx]\n", i, 586 &buf_info->base[i], buf_info->handles[i]); 587 } 588 } 589 590 mutex_lock(&c_node->mem_lock); 591 if (ipp_validate_mem_node(drm_dev, m_node, c_node)) { 592 ipp_put_mem_node(drm_dev, c_node, m_node); 593 mutex_unlock(&c_node->mem_lock); 594 return ERR_PTR(-EFAULT); 595 } 596 list_add_tail(&m_node->list, &c_node->mem_list[qbuf->ops_id]); 597 mutex_unlock(&c_node->mem_lock); 598 599 return m_node; 600 } 601 602 static void ipp_clean_mem_nodes(struct drm_device *drm_dev, 603 struct drm_exynos_ipp_cmd_node *c_node, int ops) 604 { 605 struct drm_exynos_ipp_mem_node *m_node, *tm_node; 606 struct list_head *head = &c_node->mem_list[ops]; 607 608 mutex_lock(&c_node->mem_lock); 609 610 list_for_each_entry_safe(m_node, tm_node, head, list) { 611 int ret; 612 613 ret = ipp_put_mem_node(drm_dev, c_node, m_node); 614 if (ret) 615 DRM_ERROR("failed to put m_node.\n"); 616 } 617 618 mutex_unlock(&c_node->mem_lock); 619 } 620 621 static void ipp_free_event(struct drm_pending_event *event) 622 { 623 kfree(event); 624 } 625 626 static int ipp_get_event(struct drm_device *drm_dev, 627 struct drm_exynos_ipp_cmd_node *c_node, 628 struct drm_exynos_ipp_queue_buf *qbuf) 629 { 630 struct drm_exynos_ipp_send_event *e; 631 unsigned long flags; 632 633 DRM_DEBUG_KMS("ops_id[%d]buf_id[%d]\n", qbuf->ops_id, qbuf->buf_id); 634 635 e = kzalloc(sizeof(*e), GFP_KERNEL); 636 if (!e) { 637 spin_lock_irqsave(&drm_dev->event_lock, flags); 638 c_node->filp->event_space += sizeof(e->event); 639 spin_unlock_irqrestore(&drm_dev->event_lock, flags); 640 return -ENOMEM; 641 } 642 643 /* make event */ 644 e->event.base.type = DRM_EXYNOS_IPP_EVENT; 645 e->event.base.length = sizeof(e->event); 646 e->event.user_data = qbuf->user_data; 647 e->event.prop_id = qbuf->prop_id; 648 e->event.buf_id[EXYNOS_DRM_OPS_DST] = qbuf->buf_id; 649 e->base.event = &e->event.base; 650 e->base.file_priv = c_node->filp; 651 e->base.destroy = ipp_free_event; 652 mutex_lock(&c_node->event_lock); 653 list_add_tail(&e->base.link, &c_node->event_list); 654 mutex_unlock(&c_node->event_lock); 655 656 return 0; 657 } 658 659 static void ipp_put_event(struct drm_exynos_ipp_cmd_node *c_node, 660 struct drm_exynos_ipp_queue_buf *qbuf) 661 { 662 struct drm_exynos_ipp_send_event *e, *te; 663 int count = 0; 664 665 mutex_lock(&c_node->event_lock); 666 list_for_each_entry_safe(e, te, &c_node->event_list, base.link) { 667 DRM_DEBUG_KMS("count[%d]e[%p]\n", count++, e); 668 669 /* 670 * qbuf == NULL condition means all event deletion. 671 * stop operations want to delete all event list. 672 * another case delete only same buf id. 673 */ 674 if (!qbuf) { 675 /* delete list */ 676 list_del(&e->base.link); 677 kfree(e); 678 } 679 680 /* compare buffer id */ 681 if (qbuf && (qbuf->buf_id == 682 e->event.buf_id[EXYNOS_DRM_OPS_DST])) { 683 /* delete list */ 684 list_del(&e->base.link); 685 kfree(e); 686 goto out_unlock; 687 } 688 } 689 690 out_unlock: 691 mutex_unlock(&c_node->event_lock); 692 return; 693 } 694 695 static void ipp_clean_cmd_node(struct ipp_context *ctx, 696 struct drm_exynos_ipp_cmd_node *c_node) 697 { 698 int i; 699 700 /* cancel works */ 701 cancel_work_sync(&c_node->start_work->work); 702 cancel_work_sync(&c_node->stop_work->work); 703 cancel_work_sync(&c_node->event_work->work); 704 705 /* put event */ 706 ipp_put_event(c_node, NULL); 707 708 for_each_ipp_ops(i) 709 ipp_clean_mem_nodes(ctx->subdrv.drm_dev, c_node, i); 710 711 /* delete list */ 712 list_del(&c_node->list); 713 714 ipp_remove_id(&ctx->prop_idr, &ctx->prop_lock, 715 c_node->property.prop_id); 716 717 /* destroy mutex */ 718 mutex_destroy(&c_node->lock); 719 mutex_destroy(&c_node->mem_lock); 720 mutex_destroy(&c_node->event_lock); 721 722 /* free command node */ 723 kfree(c_node->start_work); 724 kfree(c_node->stop_work); 725 kfree(c_node->event_work); 726 kfree(c_node); 727 } 728 729 static bool ipp_check_mem_list(struct drm_exynos_ipp_cmd_node *c_node) 730 { 731 switch (c_node->property.cmd) { 732 case IPP_CMD_WB: 733 return !list_empty(&c_node->mem_list[EXYNOS_DRM_OPS_DST]); 734 case IPP_CMD_OUTPUT: 735 return !list_empty(&c_node->mem_list[EXYNOS_DRM_OPS_SRC]); 736 case IPP_CMD_M2M: 737 default: 738 return !list_empty(&c_node->mem_list[EXYNOS_DRM_OPS_SRC]) && 739 !list_empty(&c_node->mem_list[EXYNOS_DRM_OPS_DST]); 740 } 741 } 742 743 static struct drm_exynos_ipp_mem_node 744 *ipp_find_mem_node(struct drm_exynos_ipp_cmd_node *c_node, 745 struct drm_exynos_ipp_queue_buf *qbuf) 746 { 747 struct drm_exynos_ipp_mem_node *m_node; 748 struct list_head *head; 749 int count = 0; 750 751 DRM_DEBUG_KMS("buf_id[%d]\n", qbuf->buf_id); 752 753 /* source/destination memory list */ 754 head = &c_node->mem_list[qbuf->ops_id]; 755 756 /* find memory node from memory list */ 757 list_for_each_entry(m_node, head, list) { 758 DRM_DEBUG_KMS("count[%d]m_node[%p]\n", count++, m_node); 759 760 /* compare buffer id */ 761 if (m_node->buf_id == qbuf->buf_id) 762 return m_node; 763 } 764 765 return NULL; 766 } 767 768 static int ipp_set_mem_node(struct exynos_drm_ippdrv *ippdrv, 769 struct drm_exynos_ipp_cmd_node *c_node, 770 struct drm_exynos_ipp_mem_node *m_node) 771 { 772 struct exynos_drm_ipp_ops *ops = NULL; 773 int ret = 0; 774 775 DRM_DEBUG_KMS("node[%p]\n", m_node); 776 777 if (!m_node) { 778 DRM_ERROR("invalid queue node.\n"); 779 return -EFAULT; 780 } 781 782 DRM_DEBUG_KMS("ops_id[%d]\n", m_node->ops_id); 783 784 /* get operations callback */ 785 ops = ippdrv->ops[m_node->ops_id]; 786 if (!ops) { 787 DRM_ERROR("not support ops.\n"); 788 return -EFAULT; 789 } 790 791 /* set address and enable irq */ 792 if (ops->set_addr) { 793 ret = ops->set_addr(ippdrv->dev, &m_node->buf_info, 794 m_node->buf_id, IPP_BUF_ENQUEUE); 795 if (ret) { 796 DRM_ERROR("failed to set addr.\n"); 797 return ret; 798 } 799 } 800 801 return ret; 802 } 803 804 static void ipp_handle_cmd_work(struct device *dev, 805 struct exynos_drm_ippdrv *ippdrv, 806 struct drm_exynos_ipp_cmd_work *cmd_work, 807 struct drm_exynos_ipp_cmd_node *c_node) 808 { 809 struct ipp_context *ctx = get_ipp_context(dev); 810 811 cmd_work->ippdrv = ippdrv; 812 cmd_work->c_node = c_node; 813 queue_work(ctx->cmd_workq, &cmd_work->work); 814 } 815 816 static int ipp_queue_buf_with_run(struct device *dev, 817 struct drm_exynos_ipp_cmd_node *c_node, 818 struct drm_exynos_ipp_mem_node *m_node, 819 struct drm_exynos_ipp_queue_buf *qbuf) 820 { 821 struct exynos_drm_ippdrv *ippdrv; 822 struct drm_exynos_ipp_property *property; 823 struct exynos_drm_ipp_ops *ops; 824 int ret; 825 826 ippdrv = ipp_find_drv_by_handle(qbuf->prop_id); 827 if (IS_ERR(ippdrv)) { 828 DRM_ERROR("failed to get ipp driver.\n"); 829 return -EFAULT; 830 } 831 832 ops = ippdrv->ops[qbuf->ops_id]; 833 if (!ops) { 834 DRM_ERROR("failed to get ops.\n"); 835 return -EFAULT; 836 } 837 838 property = &c_node->property; 839 840 if (c_node->state != IPP_STATE_START) { 841 DRM_DEBUG_KMS("bypass for invalid state.\n"); 842 return 0; 843 } 844 845 mutex_lock(&c_node->mem_lock); 846 if (!ipp_check_mem_list(c_node)) { 847 mutex_unlock(&c_node->mem_lock); 848 DRM_DEBUG_KMS("empty memory.\n"); 849 return 0; 850 } 851 852 /* 853 * If set destination buffer and enabled clock, 854 * then m2m operations need start operations at queue_buf 855 */ 856 if (ipp_is_m2m_cmd(property->cmd)) { 857 struct drm_exynos_ipp_cmd_work *cmd_work = c_node->start_work; 858 859 cmd_work->ctrl = IPP_CTRL_PLAY; 860 ipp_handle_cmd_work(dev, ippdrv, cmd_work, c_node); 861 } else { 862 ret = ipp_set_mem_node(ippdrv, c_node, m_node); 863 if (ret) { 864 mutex_unlock(&c_node->mem_lock); 865 DRM_ERROR("failed to set m node.\n"); 866 return ret; 867 } 868 } 869 mutex_unlock(&c_node->mem_lock); 870 871 return 0; 872 } 873 874 static void ipp_clean_queue_buf(struct drm_device *drm_dev, 875 struct drm_exynos_ipp_cmd_node *c_node, 876 struct drm_exynos_ipp_queue_buf *qbuf) 877 { 878 struct drm_exynos_ipp_mem_node *m_node, *tm_node; 879 880 /* delete list */ 881 mutex_lock(&c_node->mem_lock); 882 list_for_each_entry_safe(m_node, tm_node, 883 &c_node->mem_list[qbuf->ops_id], list) { 884 if (m_node->buf_id == qbuf->buf_id && 885 m_node->ops_id == qbuf->ops_id) 886 ipp_put_mem_node(drm_dev, c_node, m_node); 887 } 888 mutex_unlock(&c_node->mem_lock); 889 } 890 891 int exynos_drm_ipp_queue_buf(struct drm_device *drm_dev, void *data, 892 struct drm_file *file) 893 { 894 struct drm_exynos_file_private *file_priv = file->driver_priv; 895 struct device *dev = file_priv->ipp_dev; 896 struct ipp_context *ctx = get_ipp_context(dev); 897 struct drm_exynos_ipp_queue_buf *qbuf = data; 898 struct drm_exynos_ipp_cmd_node *c_node; 899 struct drm_exynos_ipp_mem_node *m_node; 900 int ret; 901 902 if (!qbuf) { 903 DRM_ERROR("invalid buf parameter.\n"); 904 return -EINVAL; 905 } 906 907 if (qbuf->ops_id >= EXYNOS_DRM_OPS_MAX) { 908 DRM_ERROR("invalid ops parameter.\n"); 909 return -EINVAL; 910 } 911 912 DRM_DEBUG_KMS("prop_id[%d]ops_id[%s]buf_id[%d]buf_type[%d]\n", 913 qbuf->prop_id, qbuf->ops_id ? "dst" : "src", 914 qbuf->buf_id, qbuf->buf_type); 915 916 /* find command node */ 917 c_node = ipp_find_obj(&ctx->prop_idr, &ctx->prop_lock, 918 qbuf->prop_id); 919 if (!c_node || c_node->filp != file) { 920 DRM_ERROR("failed to get command node.\n"); 921 return -ENODEV; 922 } 923 924 /* buffer control */ 925 switch (qbuf->buf_type) { 926 case IPP_BUF_ENQUEUE: 927 /* get memory node */ 928 m_node = ipp_get_mem_node(drm_dev, c_node, qbuf); 929 if (IS_ERR(m_node)) { 930 DRM_ERROR("failed to get m_node.\n"); 931 return PTR_ERR(m_node); 932 } 933 934 /* 935 * first step get event for destination buffer. 936 * and second step when M2M case run with destination buffer 937 * if needed. 938 */ 939 if (qbuf->ops_id == EXYNOS_DRM_OPS_DST) { 940 /* get event for destination buffer */ 941 ret = ipp_get_event(drm_dev, c_node, qbuf); 942 if (ret) { 943 DRM_ERROR("failed to get event.\n"); 944 goto err_clean_node; 945 } 946 947 /* 948 * M2M case run play control for streaming feature. 949 * other case set address and waiting. 950 */ 951 ret = ipp_queue_buf_with_run(dev, c_node, m_node, qbuf); 952 if (ret) { 953 DRM_ERROR("failed to run command.\n"); 954 goto err_clean_node; 955 } 956 } 957 break; 958 case IPP_BUF_DEQUEUE: 959 mutex_lock(&c_node->lock); 960 961 /* put event for destination buffer */ 962 if (qbuf->ops_id == EXYNOS_DRM_OPS_DST) 963 ipp_put_event(c_node, qbuf); 964 965 ipp_clean_queue_buf(drm_dev, c_node, qbuf); 966 967 mutex_unlock(&c_node->lock); 968 break; 969 default: 970 DRM_ERROR("invalid buffer control.\n"); 971 return -EINVAL; 972 } 973 974 return 0; 975 976 err_clean_node: 977 DRM_ERROR("clean memory nodes.\n"); 978 979 ipp_clean_queue_buf(drm_dev, c_node, qbuf); 980 return ret; 981 } 982 983 static bool exynos_drm_ipp_check_valid(struct device *dev, 984 enum drm_exynos_ipp_ctrl ctrl, enum drm_exynos_ipp_state state) 985 { 986 if (ctrl != IPP_CTRL_PLAY) { 987 if (pm_runtime_suspended(dev)) { 988 DRM_ERROR("pm:runtime_suspended.\n"); 989 goto err_status; 990 } 991 } 992 993 switch (ctrl) { 994 case IPP_CTRL_PLAY: 995 if (state != IPP_STATE_IDLE) 996 goto err_status; 997 break; 998 case IPP_CTRL_STOP: 999 if (state == IPP_STATE_STOP) 1000 goto err_status; 1001 break; 1002 case IPP_CTRL_PAUSE: 1003 if (state != IPP_STATE_START) 1004 goto err_status; 1005 break; 1006 case IPP_CTRL_RESUME: 1007 if (state != IPP_STATE_STOP) 1008 goto err_status; 1009 break; 1010 default: 1011 DRM_ERROR("invalid state.\n"); 1012 goto err_status; 1013 } 1014 1015 return true; 1016 1017 err_status: 1018 DRM_ERROR("invalid status:ctrl[%d]state[%d]\n", ctrl, state); 1019 return false; 1020 } 1021 1022 int exynos_drm_ipp_cmd_ctrl(struct drm_device *drm_dev, void *data, 1023 struct drm_file *file) 1024 { 1025 struct drm_exynos_file_private *file_priv = file->driver_priv; 1026 struct exynos_drm_ippdrv *ippdrv = NULL; 1027 struct device *dev = file_priv->ipp_dev; 1028 struct ipp_context *ctx = get_ipp_context(dev); 1029 struct drm_exynos_ipp_cmd_ctrl *cmd_ctrl = data; 1030 struct drm_exynos_ipp_cmd_work *cmd_work; 1031 struct drm_exynos_ipp_cmd_node *c_node; 1032 1033 if (!ctx) { 1034 DRM_ERROR("invalid context.\n"); 1035 return -EINVAL; 1036 } 1037 1038 if (!cmd_ctrl) { 1039 DRM_ERROR("invalid control parameter.\n"); 1040 return -EINVAL; 1041 } 1042 1043 DRM_DEBUG_KMS("ctrl[%d]prop_id[%d]\n", 1044 cmd_ctrl->ctrl, cmd_ctrl->prop_id); 1045 1046 ippdrv = ipp_find_drv_by_handle(cmd_ctrl->prop_id); 1047 if (IS_ERR(ippdrv)) { 1048 DRM_ERROR("failed to get ipp driver.\n"); 1049 return PTR_ERR(ippdrv); 1050 } 1051 1052 c_node = ipp_find_obj(&ctx->prop_idr, &ctx->prop_lock, 1053 cmd_ctrl->prop_id); 1054 if (!c_node || c_node->filp != file) { 1055 DRM_ERROR("invalid command node list.\n"); 1056 return -ENODEV; 1057 } 1058 1059 if (!exynos_drm_ipp_check_valid(ippdrv->dev, cmd_ctrl->ctrl, 1060 c_node->state)) { 1061 DRM_ERROR("invalid state.\n"); 1062 return -EINVAL; 1063 } 1064 1065 switch (cmd_ctrl->ctrl) { 1066 case IPP_CTRL_PLAY: 1067 if (pm_runtime_suspended(ippdrv->dev)) 1068 pm_runtime_get_sync(ippdrv->dev); 1069 1070 c_node->state = IPP_STATE_START; 1071 1072 cmd_work = c_node->start_work; 1073 cmd_work->ctrl = cmd_ctrl->ctrl; 1074 ipp_handle_cmd_work(dev, ippdrv, cmd_work, c_node); 1075 break; 1076 case IPP_CTRL_STOP: 1077 cmd_work = c_node->stop_work; 1078 cmd_work->ctrl = cmd_ctrl->ctrl; 1079 ipp_handle_cmd_work(dev, ippdrv, cmd_work, c_node); 1080 1081 if (!wait_for_completion_timeout(&c_node->stop_complete, 1082 msecs_to_jiffies(300))) { 1083 DRM_ERROR("timeout stop:prop_id[%d]\n", 1084 c_node->property.prop_id); 1085 } 1086 1087 c_node->state = IPP_STATE_STOP; 1088 ippdrv->dedicated = false; 1089 mutex_lock(&ippdrv->cmd_lock); 1090 ipp_clean_cmd_node(ctx, c_node); 1091 1092 if (list_empty(&ippdrv->cmd_list)) 1093 pm_runtime_put_sync(ippdrv->dev); 1094 mutex_unlock(&ippdrv->cmd_lock); 1095 break; 1096 case IPP_CTRL_PAUSE: 1097 cmd_work = c_node->stop_work; 1098 cmd_work->ctrl = cmd_ctrl->ctrl; 1099 ipp_handle_cmd_work(dev, ippdrv, cmd_work, c_node); 1100 1101 if (!wait_for_completion_timeout(&c_node->stop_complete, 1102 msecs_to_jiffies(200))) { 1103 DRM_ERROR("timeout stop:prop_id[%d]\n", 1104 c_node->property.prop_id); 1105 } 1106 1107 c_node->state = IPP_STATE_STOP; 1108 break; 1109 case IPP_CTRL_RESUME: 1110 c_node->state = IPP_STATE_START; 1111 cmd_work = c_node->start_work; 1112 cmd_work->ctrl = cmd_ctrl->ctrl; 1113 ipp_handle_cmd_work(dev, ippdrv, cmd_work, c_node); 1114 break; 1115 default: 1116 DRM_ERROR("could not support this state currently.\n"); 1117 return -EINVAL; 1118 } 1119 1120 DRM_DEBUG_KMS("done ctrl[%d]prop_id[%d]\n", 1121 cmd_ctrl->ctrl, cmd_ctrl->prop_id); 1122 1123 return 0; 1124 } 1125 1126 int exynos_drm_ippnb_register(struct notifier_block *nb) 1127 { 1128 return blocking_notifier_chain_register( 1129 &exynos_drm_ippnb_list, nb); 1130 } 1131 1132 int exynos_drm_ippnb_unregister(struct notifier_block *nb) 1133 { 1134 return blocking_notifier_chain_unregister( 1135 &exynos_drm_ippnb_list, nb); 1136 } 1137 1138 int exynos_drm_ippnb_send_event(unsigned long val, void *v) 1139 { 1140 return blocking_notifier_call_chain( 1141 &exynos_drm_ippnb_list, val, v); 1142 } 1143 1144 static int ipp_set_property(struct exynos_drm_ippdrv *ippdrv, 1145 struct drm_exynos_ipp_property *property) 1146 { 1147 struct exynos_drm_ipp_ops *ops = NULL; 1148 bool swap = false; 1149 int ret, i; 1150 1151 if (!property) { 1152 DRM_ERROR("invalid property parameter.\n"); 1153 return -EINVAL; 1154 } 1155 1156 DRM_DEBUG_KMS("prop_id[%d]\n", property->prop_id); 1157 1158 /* reset h/w block */ 1159 if (ippdrv->reset && 1160 ippdrv->reset(ippdrv->dev)) { 1161 return -EINVAL; 1162 } 1163 1164 /* set source,destination operations */ 1165 for_each_ipp_ops(i) { 1166 struct drm_exynos_ipp_config *config = 1167 &property->config[i]; 1168 1169 ops = ippdrv->ops[i]; 1170 if (!ops || !config) { 1171 DRM_ERROR("not support ops and config.\n"); 1172 return -EINVAL; 1173 } 1174 1175 /* set format */ 1176 if (ops->set_fmt) { 1177 ret = ops->set_fmt(ippdrv->dev, config->fmt); 1178 if (ret) 1179 return ret; 1180 } 1181 1182 /* set transform for rotation, flip */ 1183 if (ops->set_transf) { 1184 ret = ops->set_transf(ippdrv->dev, config->degree, 1185 config->flip, &swap); 1186 if (ret) 1187 return ret; 1188 } 1189 1190 /* set size */ 1191 if (ops->set_size) { 1192 ret = ops->set_size(ippdrv->dev, swap, &config->pos, 1193 &config->sz); 1194 if (ret) 1195 return ret; 1196 } 1197 } 1198 1199 return 0; 1200 } 1201 1202 static int ipp_start_property(struct exynos_drm_ippdrv *ippdrv, 1203 struct drm_exynos_ipp_cmd_node *c_node) 1204 { 1205 struct drm_exynos_ipp_mem_node *m_node; 1206 struct drm_exynos_ipp_property *property = &c_node->property; 1207 struct list_head *head; 1208 int ret, i; 1209 1210 DRM_DEBUG_KMS("prop_id[%d]\n", property->prop_id); 1211 1212 /* store command info in ippdrv */ 1213 ippdrv->c_node = c_node; 1214 1215 mutex_lock(&c_node->mem_lock); 1216 if (!ipp_check_mem_list(c_node)) { 1217 DRM_DEBUG_KMS("empty memory.\n"); 1218 ret = -ENOMEM; 1219 goto err_unlock; 1220 } 1221 1222 /* set current property in ippdrv */ 1223 ret = ipp_set_property(ippdrv, property); 1224 if (ret) { 1225 DRM_ERROR("failed to set property.\n"); 1226 ippdrv->c_node = NULL; 1227 goto err_unlock; 1228 } 1229 1230 /* check command */ 1231 switch (property->cmd) { 1232 case IPP_CMD_M2M: 1233 for_each_ipp_ops(i) { 1234 /* source/destination memory list */ 1235 head = &c_node->mem_list[i]; 1236 1237 m_node = list_first_entry(head, 1238 struct drm_exynos_ipp_mem_node, list); 1239 1240 DRM_DEBUG_KMS("m_node[%p]\n", m_node); 1241 1242 ret = ipp_set_mem_node(ippdrv, c_node, m_node); 1243 if (ret) { 1244 DRM_ERROR("failed to set m node.\n"); 1245 goto err_unlock; 1246 } 1247 } 1248 break; 1249 case IPP_CMD_WB: 1250 /* destination memory list */ 1251 head = &c_node->mem_list[EXYNOS_DRM_OPS_DST]; 1252 1253 list_for_each_entry(m_node, head, list) { 1254 ret = ipp_set_mem_node(ippdrv, c_node, m_node); 1255 if (ret) { 1256 DRM_ERROR("failed to set m node.\n"); 1257 goto err_unlock; 1258 } 1259 } 1260 break; 1261 case IPP_CMD_OUTPUT: 1262 /* source memory list */ 1263 head = &c_node->mem_list[EXYNOS_DRM_OPS_SRC]; 1264 1265 list_for_each_entry(m_node, head, list) { 1266 ret = ipp_set_mem_node(ippdrv, c_node, m_node); 1267 if (ret) { 1268 DRM_ERROR("failed to set m node.\n"); 1269 goto err_unlock; 1270 } 1271 } 1272 break; 1273 default: 1274 DRM_ERROR("invalid operations.\n"); 1275 ret = -EINVAL; 1276 goto err_unlock; 1277 } 1278 mutex_unlock(&c_node->mem_lock); 1279 1280 DRM_DEBUG_KMS("cmd[%d]\n", property->cmd); 1281 1282 /* start operations */ 1283 if (ippdrv->start) { 1284 ret = ippdrv->start(ippdrv->dev, property->cmd); 1285 if (ret) { 1286 DRM_ERROR("failed to start ops.\n"); 1287 ippdrv->c_node = NULL; 1288 return ret; 1289 } 1290 } 1291 1292 return 0; 1293 1294 err_unlock: 1295 mutex_unlock(&c_node->mem_lock); 1296 ippdrv->c_node = NULL; 1297 return ret; 1298 } 1299 1300 static int ipp_stop_property(struct drm_device *drm_dev, 1301 struct exynos_drm_ippdrv *ippdrv, 1302 struct drm_exynos_ipp_cmd_node *c_node) 1303 { 1304 struct drm_exynos_ipp_property *property = &c_node->property; 1305 int i; 1306 1307 DRM_DEBUG_KMS("prop_id[%d]\n", property->prop_id); 1308 1309 /* stop operations */ 1310 if (ippdrv->stop) 1311 ippdrv->stop(ippdrv->dev, property->cmd); 1312 1313 /* check command */ 1314 switch (property->cmd) { 1315 case IPP_CMD_M2M: 1316 for_each_ipp_ops(i) 1317 ipp_clean_mem_nodes(drm_dev, c_node, i); 1318 break; 1319 case IPP_CMD_WB: 1320 ipp_clean_mem_nodes(drm_dev, c_node, EXYNOS_DRM_OPS_DST); 1321 break; 1322 case IPP_CMD_OUTPUT: 1323 ipp_clean_mem_nodes(drm_dev, c_node, EXYNOS_DRM_OPS_SRC); 1324 break; 1325 default: 1326 DRM_ERROR("invalid operations.\n"); 1327 return -EINVAL; 1328 } 1329 1330 return 0; 1331 } 1332 1333 void ipp_sched_cmd(struct work_struct *work) 1334 { 1335 struct drm_exynos_ipp_cmd_work *cmd_work = 1336 container_of(work, struct drm_exynos_ipp_cmd_work, work); 1337 struct exynos_drm_ippdrv *ippdrv; 1338 struct drm_exynos_ipp_cmd_node *c_node; 1339 struct drm_exynos_ipp_property *property; 1340 int ret; 1341 1342 ippdrv = cmd_work->ippdrv; 1343 if (!ippdrv) { 1344 DRM_ERROR("invalid ippdrv list.\n"); 1345 return; 1346 } 1347 1348 c_node = cmd_work->c_node; 1349 if (!c_node) { 1350 DRM_ERROR("invalid command node list.\n"); 1351 return; 1352 } 1353 1354 mutex_lock(&c_node->lock); 1355 1356 property = &c_node->property; 1357 1358 switch (cmd_work->ctrl) { 1359 case IPP_CTRL_PLAY: 1360 case IPP_CTRL_RESUME: 1361 ret = ipp_start_property(ippdrv, c_node); 1362 if (ret) { 1363 DRM_ERROR("failed to start property:prop_id[%d]\n", 1364 c_node->property.prop_id); 1365 goto err_unlock; 1366 } 1367 1368 /* 1369 * M2M case supports wait_completion of transfer. 1370 * because M2M case supports single unit operation 1371 * with multiple queue. 1372 * M2M need to wait completion of data transfer. 1373 */ 1374 if (ipp_is_m2m_cmd(property->cmd)) { 1375 if (!wait_for_completion_timeout 1376 (&c_node->start_complete, msecs_to_jiffies(200))) { 1377 DRM_ERROR("timeout event:prop_id[%d]\n", 1378 c_node->property.prop_id); 1379 goto err_unlock; 1380 } 1381 } 1382 break; 1383 case IPP_CTRL_STOP: 1384 case IPP_CTRL_PAUSE: 1385 ret = ipp_stop_property(ippdrv->drm_dev, ippdrv, 1386 c_node); 1387 if (ret) { 1388 DRM_ERROR("failed to stop property.\n"); 1389 goto err_unlock; 1390 } 1391 1392 complete(&c_node->stop_complete); 1393 break; 1394 default: 1395 DRM_ERROR("unknown control type\n"); 1396 break; 1397 } 1398 1399 DRM_DEBUG_KMS("ctrl[%d] done.\n", cmd_work->ctrl); 1400 1401 err_unlock: 1402 mutex_unlock(&c_node->lock); 1403 } 1404 1405 static int ipp_send_event(struct exynos_drm_ippdrv *ippdrv, 1406 struct drm_exynos_ipp_cmd_node *c_node, int *buf_id) 1407 { 1408 struct drm_device *drm_dev = ippdrv->drm_dev; 1409 struct drm_exynos_ipp_property *property = &c_node->property; 1410 struct drm_exynos_ipp_mem_node *m_node; 1411 struct drm_exynos_ipp_queue_buf qbuf; 1412 struct drm_exynos_ipp_send_event *e; 1413 struct list_head *head; 1414 struct timeval now; 1415 unsigned long flags; 1416 u32 tbuf_id[EXYNOS_DRM_OPS_MAX] = {0, }; 1417 int ret, i; 1418 1419 for_each_ipp_ops(i) 1420 DRM_DEBUG_KMS("%s buf_id[%d]\n", i ? "dst" : "src", buf_id[i]); 1421 1422 if (!drm_dev) { 1423 DRM_ERROR("failed to get drm_dev.\n"); 1424 return -EINVAL; 1425 } 1426 1427 if (!property) { 1428 DRM_ERROR("failed to get property.\n"); 1429 return -EINVAL; 1430 } 1431 1432 mutex_lock(&c_node->event_lock); 1433 if (list_empty(&c_node->event_list)) { 1434 DRM_DEBUG_KMS("event list is empty.\n"); 1435 ret = 0; 1436 goto err_event_unlock; 1437 } 1438 1439 mutex_lock(&c_node->mem_lock); 1440 if (!ipp_check_mem_list(c_node)) { 1441 DRM_DEBUG_KMS("empty memory.\n"); 1442 ret = 0; 1443 goto err_mem_unlock; 1444 } 1445 1446 /* check command */ 1447 switch (property->cmd) { 1448 case IPP_CMD_M2M: 1449 for_each_ipp_ops(i) { 1450 /* source/destination memory list */ 1451 head = &c_node->mem_list[i]; 1452 1453 m_node = list_first_entry(head, 1454 struct drm_exynos_ipp_mem_node, list); 1455 1456 tbuf_id[i] = m_node->buf_id; 1457 DRM_DEBUG_KMS("%s buf_id[%d]\n", 1458 i ? "dst" : "src", tbuf_id[i]); 1459 1460 ret = ipp_put_mem_node(drm_dev, c_node, m_node); 1461 if (ret) 1462 DRM_ERROR("failed to put m_node.\n"); 1463 } 1464 break; 1465 case IPP_CMD_WB: 1466 /* clear buf for finding */ 1467 memset(&qbuf, 0x0, sizeof(qbuf)); 1468 qbuf.ops_id = EXYNOS_DRM_OPS_DST; 1469 qbuf.buf_id = buf_id[EXYNOS_DRM_OPS_DST]; 1470 1471 /* get memory node entry */ 1472 m_node = ipp_find_mem_node(c_node, &qbuf); 1473 if (!m_node) { 1474 DRM_ERROR("empty memory node.\n"); 1475 ret = -ENOMEM; 1476 goto err_mem_unlock; 1477 } 1478 1479 tbuf_id[EXYNOS_DRM_OPS_DST] = m_node->buf_id; 1480 1481 ret = ipp_put_mem_node(drm_dev, c_node, m_node); 1482 if (ret) 1483 DRM_ERROR("failed to put m_node.\n"); 1484 break; 1485 case IPP_CMD_OUTPUT: 1486 /* source memory list */ 1487 head = &c_node->mem_list[EXYNOS_DRM_OPS_SRC]; 1488 1489 m_node = list_first_entry(head, 1490 struct drm_exynos_ipp_mem_node, list); 1491 1492 tbuf_id[EXYNOS_DRM_OPS_SRC] = m_node->buf_id; 1493 1494 ret = ipp_put_mem_node(drm_dev, c_node, m_node); 1495 if (ret) 1496 DRM_ERROR("failed to put m_node.\n"); 1497 break; 1498 default: 1499 DRM_ERROR("invalid operations.\n"); 1500 ret = -EINVAL; 1501 goto err_mem_unlock; 1502 } 1503 mutex_unlock(&c_node->mem_lock); 1504 1505 if (tbuf_id[EXYNOS_DRM_OPS_DST] != buf_id[EXYNOS_DRM_OPS_DST]) 1506 DRM_ERROR("failed to match buf_id[%d %d]prop_id[%d]\n", 1507 tbuf_id[1], buf_id[1], property->prop_id); 1508 1509 /* 1510 * command node have event list of destination buffer 1511 * If destination buffer enqueue to mem list, 1512 * then we make event and link to event list tail. 1513 * so, we get first event for first enqueued buffer. 1514 */ 1515 e = list_first_entry(&c_node->event_list, 1516 struct drm_exynos_ipp_send_event, base.link); 1517 1518 do_gettimeofday(&now); 1519 DRM_DEBUG_KMS("tv_sec[%ld]tv_usec[%ld]\n", now.tv_sec, now.tv_usec); 1520 e->event.tv_sec = now.tv_sec; 1521 e->event.tv_usec = now.tv_usec; 1522 e->event.prop_id = property->prop_id; 1523 1524 /* set buffer id about source destination */ 1525 for_each_ipp_ops(i) 1526 e->event.buf_id[i] = tbuf_id[i]; 1527 1528 spin_lock_irqsave(&drm_dev->event_lock, flags); 1529 list_move_tail(&e->base.link, &e->base.file_priv->event_list); 1530 wake_up_interruptible(&e->base.file_priv->event_wait); 1531 spin_unlock_irqrestore(&drm_dev->event_lock, flags); 1532 mutex_unlock(&c_node->event_lock); 1533 1534 DRM_DEBUG_KMS("done cmd[%d]prop_id[%d]buf_id[%d]\n", 1535 property->cmd, property->prop_id, tbuf_id[EXYNOS_DRM_OPS_DST]); 1536 1537 return 0; 1538 1539 err_mem_unlock: 1540 mutex_unlock(&c_node->mem_lock); 1541 err_event_unlock: 1542 mutex_unlock(&c_node->event_lock); 1543 return ret; 1544 } 1545 1546 void ipp_sched_event(struct work_struct *work) 1547 { 1548 struct drm_exynos_ipp_event_work *event_work = 1549 container_of(work, struct drm_exynos_ipp_event_work, work); 1550 struct exynos_drm_ippdrv *ippdrv; 1551 struct drm_exynos_ipp_cmd_node *c_node; 1552 int ret; 1553 1554 if (!event_work) { 1555 DRM_ERROR("failed to get event_work.\n"); 1556 return; 1557 } 1558 1559 DRM_DEBUG_KMS("buf_id[%d]\n", event_work->buf_id[EXYNOS_DRM_OPS_DST]); 1560 1561 ippdrv = event_work->ippdrv; 1562 if (!ippdrv) { 1563 DRM_ERROR("failed to get ipp driver.\n"); 1564 return; 1565 } 1566 1567 c_node = ippdrv->c_node; 1568 if (!c_node) { 1569 DRM_ERROR("failed to get command node.\n"); 1570 return; 1571 } 1572 1573 /* 1574 * IPP supports command thread, event thread synchronization. 1575 * If IPP close immediately from user land, then IPP make 1576 * synchronization with command thread, so make complete event. 1577 * or going out operations. 1578 */ 1579 if (c_node->state != IPP_STATE_START) { 1580 DRM_DEBUG_KMS("bypass state[%d]prop_id[%d]\n", 1581 c_node->state, c_node->property.prop_id); 1582 goto err_completion; 1583 } 1584 1585 ret = ipp_send_event(ippdrv, c_node, event_work->buf_id); 1586 if (ret) { 1587 DRM_ERROR("failed to send event.\n"); 1588 goto err_completion; 1589 } 1590 1591 err_completion: 1592 if (ipp_is_m2m_cmd(c_node->property.cmd)) 1593 complete(&c_node->start_complete); 1594 } 1595 1596 static int ipp_subdrv_probe(struct drm_device *drm_dev, struct device *dev) 1597 { 1598 struct ipp_context *ctx = get_ipp_context(dev); 1599 struct exynos_drm_ippdrv *ippdrv; 1600 int ret, count = 0; 1601 1602 /* get ipp driver entry */ 1603 list_for_each_entry(ippdrv, &exynos_drm_ippdrv_list, drv_list) { 1604 ippdrv->drm_dev = drm_dev; 1605 1606 ret = ipp_create_id(&ctx->ipp_idr, &ctx->ipp_lock, ippdrv); 1607 if (ret < 0) { 1608 DRM_ERROR("failed to create id.\n"); 1609 goto err; 1610 } 1611 ippdrv->prop_list.ipp_id = ret; 1612 1613 DRM_DEBUG_KMS("count[%d]ippdrv[%p]ipp_id[%d]\n", 1614 count++, ippdrv, ret); 1615 1616 /* store parent device for node */ 1617 ippdrv->parent_dev = dev; 1618 1619 /* store event work queue and handler */ 1620 ippdrv->event_workq = ctx->event_workq; 1621 ippdrv->sched_event = ipp_sched_event; 1622 INIT_LIST_HEAD(&ippdrv->cmd_list); 1623 mutex_init(&ippdrv->cmd_lock); 1624 1625 ret = drm_iommu_attach_device(drm_dev, ippdrv->dev); 1626 if (ret) { 1627 DRM_ERROR("failed to activate iommu\n"); 1628 goto err; 1629 } 1630 } 1631 1632 return 0; 1633 1634 err: 1635 /* get ipp driver entry */ 1636 list_for_each_entry_continue_reverse(ippdrv, &exynos_drm_ippdrv_list, 1637 drv_list) { 1638 drm_iommu_detach_device(drm_dev, ippdrv->dev); 1639 1640 ipp_remove_id(&ctx->ipp_idr, &ctx->ipp_lock, 1641 ippdrv->prop_list.ipp_id); 1642 } 1643 1644 return ret; 1645 } 1646 1647 static void ipp_subdrv_remove(struct drm_device *drm_dev, struct device *dev) 1648 { 1649 struct exynos_drm_ippdrv *ippdrv, *t; 1650 struct ipp_context *ctx = get_ipp_context(dev); 1651 1652 /* get ipp driver entry */ 1653 list_for_each_entry_safe(ippdrv, t, &exynos_drm_ippdrv_list, drv_list) { 1654 drm_iommu_detach_device(drm_dev, ippdrv->dev); 1655 1656 ipp_remove_id(&ctx->ipp_idr, &ctx->ipp_lock, 1657 ippdrv->prop_list.ipp_id); 1658 1659 ippdrv->drm_dev = NULL; 1660 exynos_drm_ippdrv_unregister(ippdrv); 1661 } 1662 } 1663 1664 static int ipp_subdrv_open(struct drm_device *drm_dev, struct device *dev, 1665 struct drm_file *file) 1666 { 1667 struct drm_exynos_file_private *file_priv = file->driver_priv; 1668 1669 file_priv->ipp_dev = dev; 1670 1671 DRM_DEBUG_KMS("done priv[%p]\n", dev); 1672 1673 return 0; 1674 } 1675 1676 static void ipp_subdrv_close(struct drm_device *drm_dev, struct device *dev, 1677 struct drm_file *file) 1678 { 1679 struct exynos_drm_ippdrv *ippdrv = NULL; 1680 struct ipp_context *ctx = get_ipp_context(dev); 1681 struct drm_exynos_ipp_cmd_node *c_node, *tc_node; 1682 int count = 0; 1683 1684 list_for_each_entry(ippdrv, &exynos_drm_ippdrv_list, drv_list) { 1685 mutex_lock(&ippdrv->cmd_lock); 1686 list_for_each_entry_safe(c_node, tc_node, 1687 &ippdrv->cmd_list, list) { 1688 DRM_DEBUG_KMS("count[%d]ippdrv[%p]\n", 1689 count++, ippdrv); 1690 1691 if (c_node->filp == file) { 1692 /* 1693 * userland goto unnormal state. process killed. 1694 * and close the file. 1695 * so, IPP didn't called stop cmd ctrl. 1696 * so, we are make stop operation in this state. 1697 */ 1698 if (c_node->state == IPP_STATE_START) { 1699 ipp_stop_property(drm_dev, ippdrv, 1700 c_node); 1701 c_node->state = IPP_STATE_STOP; 1702 } 1703 1704 ippdrv->dedicated = false; 1705 ipp_clean_cmd_node(ctx, c_node); 1706 if (list_empty(&ippdrv->cmd_list)) 1707 pm_runtime_put_sync(ippdrv->dev); 1708 } 1709 } 1710 mutex_unlock(&ippdrv->cmd_lock); 1711 } 1712 1713 return; 1714 } 1715 1716 static int ipp_probe(struct platform_device *pdev) 1717 { 1718 struct device *dev = &pdev->dev; 1719 struct ipp_context *ctx; 1720 struct exynos_drm_subdrv *subdrv; 1721 int ret; 1722 1723 ctx = devm_kzalloc(dev, sizeof(*ctx), GFP_KERNEL); 1724 if (!ctx) 1725 return -ENOMEM; 1726 1727 mutex_init(&ctx->ipp_lock); 1728 mutex_init(&ctx->prop_lock); 1729 1730 idr_init(&ctx->ipp_idr); 1731 idr_init(&ctx->prop_idr); 1732 1733 /* 1734 * create single thread for ipp event 1735 * IPP supports event thread for IPP drivers. 1736 * IPP driver send event_work to this thread. 1737 * and IPP event thread send event to user process. 1738 */ 1739 ctx->event_workq = create_singlethread_workqueue("ipp_event"); 1740 if (!ctx->event_workq) { 1741 dev_err(dev, "failed to create event workqueue\n"); 1742 return -EINVAL; 1743 } 1744 1745 /* 1746 * create single thread for ipp command 1747 * IPP supports command thread for user process. 1748 * user process make command node using set property ioctl. 1749 * and make start_work and send this work to command thread. 1750 * and then this command thread start property. 1751 */ 1752 ctx->cmd_workq = create_singlethread_workqueue("ipp_cmd"); 1753 if (!ctx->cmd_workq) { 1754 dev_err(dev, "failed to create cmd workqueue\n"); 1755 ret = -EINVAL; 1756 goto err_event_workq; 1757 } 1758 1759 /* set sub driver informations */ 1760 subdrv = &ctx->subdrv; 1761 subdrv->dev = dev; 1762 subdrv->probe = ipp_subdrv_probe; 1763 subdrv->remove = ipp_subdrv_remove; 1764 subdrv->open = ipp_subdrv_open; 1765 subdrv->close = ipp_subdrv_close; 1766 1767 platform_set_drvdata(pdev, ctx); 1768 1769 ret = exynos_drm_subdrv_register(subdrv); 1770 if (ret < 0) { 1771 DRM_ERROR("failed to register drm ipp device.\n"); 1772 goto err_cmd_workq; 1773 } 1774 1775 dev_info(dev, "drm ipp registered successfully.\n"); 1776 1777 return 0; 1778 1779 err_cmd_workq: 1780 destroy_workqueue(ctx->cmd_workq); 1781 err_event_workq: 1782 destroy_workqueue(ctx->event_workq); 1783 return ret; 1784 } 1785 1786 static int ipp_remove(struct platform_device *pdev) 1787 { 1788 struct ipp_context *ctx = platform_get_drvdata(pdev); 1789 1790 /* unregister sub driver */ 1791 exynos_drm_subdrv_unregister(&ctx->subdrv); 1792 1793 /* remove,destroy ipp idr */ 1794 idr_destroy(&ctx->ipp_idr); 1795 idr_destroy(&ctx->prop_idr); 1796 1797 mutex_destroy(&ctx->ipp_lock); 1798 mutex_destroy(&ctx->prop_lock); 1799 1800 /* destroy command, event work queue */ 1801 destroy_workqueue(ctx->cmd_workq); 1802 destroy_workqueue(ctx->event_workq); 1803 1804 return 0; 1805 } 1806 1807 struct platform_driver ipp_driver = { 1808 .probe = ipp_probe, 1809 .remove = ipp_remove, 1810 .driver = { 1811 .name = "exynos-drm-ipp", 1812 .owner = THIS_MODULE, 1813 }, 1814 }; 1815 1816