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