.. | .. |
---|
22 | 22 | #include <linux/reset.h> |
---|
23 | 23 | #include <linux/irqreturn.h> |
---|
24 | 24 | #include <linux/poll.h> |
---|
| 25 | +#include <linux/platform_device.h> |
---|
| 26 | +#include <soc/rockchip/pm_domains.h> |
---|
| 27 | +#include <uapi/linux/rk-mpp.h> |
---|
25 | 28 | |
---|
26 | | -#define MHZ (1000 * 1000) |
---|
| 29 | +#define MHZ (1000 * 1000) |
---|
| 30 | +#define MPP_WORK_TIMEOUT_DELAY (500) |
---|
27 | 31 | |
---|
28 | 32 | #define MPP_MAX_MSG_NUM (16) |
---|
29 | 33 | #define MPP_MAX_REG_TRANS_NUM (60) |
---|
30 | 34 | #define MPP_MAX_TASK_CAPACITY (16) |
---|
31 | | -/* define flags for mpp_request */ |
---|
32 | | -#define MPP_FLAGS_MULTI_MSG (0x00000001) |
---|
33 | | -#define MPP_FLAGS_LAST_MSG (0x00000002) |
---|
34 | | -#define MPP_FLAGS_REG_FD_NO_TRANS (0x00000004) |
---|
35 | | -#define MPP_FLAGS_SCL_FD_NO_TRANS (0x00000008) |
---|
36 | | -#define MPP_FLAGS_REG_NO_OFFSET (0x00000010) |
---|
37 | | -#define MPP_FLAGS_SECURE_MODE (0x00010000) |
---|
38 | 35 | |
---|
39 | 36 | /* grf mask for get value */ |
---|
40 | 37 | #define MPP_GRF_VAL_MASK (0xFFFF) |
---|
| 38 | + |
---|
| 39 | +/* max 4 cores supported */ |
---|
| 40 | +#define MPP_MAX_CORE_NUM (4) |
---|
41 | 41 | |
---|
42 | 42 | /** |
---|
43 | 43 | * Device type: classified by hardware feature |
---|
.. | .. |
---|
46 | 46 | MPP_DEVICE_VDPU1 = 0, /* 0x00000001 */ |
---|
47 | 47 | MPP_DEVICE_VDPU2 = 1, /* 0x00000002 */ |
---|
48 | 48 | MPP_DEVICE_VDPU1_PP = 2, /* 0x00000004 */ |
---|
49 | | - MPP_DEVICE_VDPU2_PP = 3, /* 0x00000008 */ |
---|
| 49 | + MPP_DEVICE_VDPU2_PP = 3, /* 0x00000008 */ |
---|
| 50 | + MPP_DEVICE_AV1DEC = 4, /* 0x00000010 */ |
---|
50 | 51 | |
---|
51 | 52 | MPP_DEVICE_HEVC_DEC = 8, /* 0x00000100 */ |
---|
52 | 53 | MPP_DEVICE_RKVDEC = 9, /* 0x00000200 */ |
---|
53 | 54 | MPP_DEVICE_AVSPLUS_DEC = 12, /* 0x00001000 */ |
---|
54 | | - MPP_DEVICE_JPGDEC = 13, /* 0x00002000 */ |
---|
| 55 | + MPP_DEVICE_RKJPEGD = 13, /* 0x00002000 */ |
---|
55 | 56 | |
---|
56 | 57 | MPP_DEVICE_RKVENC = 16, /* 0x00010000 */ |
---|
57 | 58 | MPP_DEVICE_VEPU1 = 17, /* 0x00020000 */ |
---|
58 | 59 | MPP_DEVICE_VEPU2 = 18, /* 0x00040000 */ |
---|
| 60 | + MPP_DEVICE_VEPU2_JPEG = 19, /* 0x00080000 */ |
---|
59 | 61 | MPP_DEVICE_VEPU22 = 24, /* 0x01000000 */ |
---|
60 | 62 | |
---|
61 | 63 | MPP_DEVICE_IEP2 = 28, /* 0x10000000 */ |
---|
.. | .. |
---|
79 | 81 | MPP_DRIVER_IEP2, |
---|
80 | 82 | MPP_DRIVER_JPGDEC, |
---|
81 | 83 | MPP_DRIVER_RKVDEC2, |
---|
82 | | - MPP_DRIVER_VDPP, |
---|
83 | 84 | MPP_DRIVER_RKVENC2, |
---|
| 85 | + MPP_DRIVER_AV1DEC, |
---|
| 86 | + MPP_DRIVER_VDPP, |
---|
84 | 87 | MPP_DRIVER_BUTT, |
---|
85 | | -}; |
---|
86 | | - |
---|
87 | | -/** |
---|
88 | | - * Command type: keep the same as user space |
---|
89 | | - */ |
---|
90 | | -enum MPP_DEV_COMMAND_TYPE { |
---|
91 | | - MPP_CMD_QUERY_BASE = 0, |
---|
92 | | - MPP_CMD_QUERY_HW_SUPPORT = MPP_CMD_QUERY_BASE + 0, |
---|
93 | | - MPP_CMD_QUERY_HW_ID = MPP_CMD_QUERY_BASE + 1, |
---|
94 | | - MPP_CMD_QUERY_CMD_SUPPORT = MPP_CMD_QUERY_BASE + 2, |
---|
95 | | - MPP_CMD_QUERY_BUTT, |
---|
96 | | - |
---|
97 | | - MPP_CMD_INIT_BASE = 0x100, |
---|
98 | | - MPP_CMD_INIT_CLIENT_TYPE = MPP_CMD_INIT_BASE + 0, |
---|
99 | | - MPP_CMD_INIT_DRIVER_DATA = MPP_CMD_INIT_BASE + 1, |
---|
100 | | - MPP_CMD_INIT_TRANS_TABLE = MPP_CMD_INIT_BASE + 2, |
---|
101 | | - MPP_CMD_INIT_BUTT, |
---|
102 | | - |
---|
103 | | - MPP_CMD_SEND_BASE = 0x200, |
---|
104 | | - MPP_CMD_SET_REG_WRITE = MPP_CMD_SEND_BASE + 0, |
---|
105 | | - MPP_CMD_SET_REG_READ = MPP_CMD_SEND_BASE + 1, |
---|
106 | | - MPP_CMD_SET_REG_ADDR_OFFSET = MPP_CMD_SEND_BASE + 2, |
---|
107 | | - MPP_CMD_SET_RCB_INFO = MPP_CMD_SEND_BASE + 3, |
---|
108 | | - MPP_CMD_SEND_BUTT, |
---|
109 | | - |
---|
110 | | - MPP_CMD_POLL_BASE = 0x300, |
---|
111 | | - MPP_CMD_POLL_HW_FINISH = MPP_CMD_POLL_BASE + 0, |
---|
112 | | - MPP_CMD_POLL_BUTT, |
---|
113 | | - |
---|
114 | | - MPP_CMD_CONTROL_BASE = 0x400, |
---|
115 | | - MPP_CMD_RESET_SESSION = MPP_CMD_CONTROL_BASE + 0, |
---|
116 | | - MPP_CMD_TRANS_FD_TO_IOVA = MPP_CMD_CONTROL_BASE + 1, |
---|
117 | | - MPP_CMD_RELEASE_FD = MPP_CMD_CONTROL_BASE + 2, |
---|
118 | | - MPP_CMD_SEND_CODEC_INFO = MPP_CMD_CONTROL_BASE + 3, |
---|
119 | | - MPP_CMD_CONTROL_BUTT, |
---|
120 | | - |
---|
121 | | - MPP_CMD_BUTT, |
---|
122 | 88 | }; |
---|
123 | 89 | |
---|
124 | 90 | enum MPP_CLOCK_MODE { |
---|
.. | .. |
---|
178 | 144 | CODEC_INFO_FLAG_BUTT, |
---|
179 | 145 | }; |
---|
180 | 146 | |
---|
181 | | -/* data common struct for parse out */ |
---|
182 | | -struct mpp_request { |
---|
183 | | - __u32 cmd; |
---|
184 | | - __u32 flags; |
---|
185 | | - __u32 size; |
---|
186 | | - __u32 offset; |
---|
187 | | - void __user *data; |
---|
188 | | -}; |
---|
| 147 | +struct mpp_task; |
---|
| 148 | +struct mpp_session; |
---|
| 149 | +struct mpp_dma_session; |
---|
| 150 | +struct mpp_taskqueue; |
---|
| 151 | +struct iommu_domain; |
---|
189 | 152 | |
---|
190 | 153 | /* struct use to collect task set and poll message */ |
---|
191 | 154 | struct mpp_task_msgs { |
---|
| 155 | + /* for ioctl msgs bat process */ |
---|
| 156 | + struct list_head list; |
---|
| 157 | + struct list_head list_session; |
---|
| 158 | + |
---|
| 159 | + struct mpp_session *session; |
---|
| 160 | + struct mpp_taskqueue *queue; |
---|
| 161 | + struct mpp_task *task; |
---|
| 162 | + struct mpp_dev *mpp; |
---|
| 163 | + |
---|
| 164 | + /* for fd reference */ |
---|
| 165 | + int ext_fd; |
---|
| 166 | + struct fd f; |
---|
| 167 | + |
---|
192 | 168 | u32 flags; |
---|
193 | 169 | u32 req_cnt; |
---|
194 | | - struct mpp_request reqs[MPP_MAX_MSG_NUM]; |
---|
195 | 170 | u32 set_cnt; |
---|
196 | 171 | u32 poll_cnt; |
---|
| 172 | + |
---|
| 173 | + struct mpp_request reqs[MPP_MAX_MSG_NUM]; |
---|
| 174 | + struct mpp_request *poll_req; |
---|
197 | 175 | }; |
---|
198 | 176 | |
---|
199 | 177 | struct mpp_grf_info { |
---|
.. | .. |
---|
255 | 233 | u32 reduce_rate_hz; |
---|
256 | 234 | /* record last used rate */ |
---|
257 | 235 | u32 used_rate_hz; |
---|
| 236 | + u32 real_rate_hz; |
---|
258 | 237 | }; |
---|
259 | 238 | |
---|
260 | 239 | struct mpp_dev_var { |
---|
.. | .. |
---|
279 | 258 | bool is_dup; |
---|
280 | 259 | }; |
---|
281 | 260 | |
---|
282 | | -struct mpp_dma_session; |
---|
283 | | - |
---|
284 | | -struct mpp_taskqueue; |
---|
285 | 261 | |
---|
286 | 262 | struct mpp_dev { |
---|
287 | 263 | struct device *dev; |
---|
.. | .. |
---|
293 | 269 | struct kthread_work work; |
---|
294 | 270 | /* the flag for get/get/reduce freq */ |
---|
295 | 271 | bool auto_freq_en; |
---|
| 272 | + /* the flag for pmu idle request before device reset */ |
---|
| 273 | + bool skip_idle; |
---|
296 | 274 | |
---|
297 | 275 | /* |
---|
298 | 276 | * The task capacity is the task queue length that hardware can accept. |
---|
299 | 277 | * Default 1 means normal hardware can only accept one task at once. |
---|
300 | 278 | */ |
---|
301 | 279 | u32 task_capacity; |
---|
| 280 | + /* |
---|
| 281 | + * The message capacity is the max message parallel process capacity. |
---|
| 282 | + * Default 1 means normal hardware can only accept one message at one |
---|
| 283 | + * shot ioctl. |
---|
| 284 | + * Multi-core hardware can accept more message at one shot ioctl. |
---|
| 285 | + */ |
---|
| 286 | + u32 msgs_cap; |
---|
302 | 287 | |
---|
303 | 288 | int irq; |
---|
| 289 | + bool is_irq_startup; |
---|
304 | 290 | u32 irq_status; |
---|
305 | 291 | |
---|
306 | 292 | void __iomem *reg_base; |
---|
307 | 293 | struct mpp_grf_info *grf_info; |
---|
308 | 294 | struct mpp_iommu_info *iommu_info; |
---|
| 295 | + int (*fault_handler)(struct iommu_domain *iommu, struct device *iommu_dev, |
---|
| 296 | + unsigned long iova, int status, void *arg); |
---|
| 297 | + resource_size_t io_base; |
---|
309 | 298 | |
---|
310 | 299 | atomic_t reset_request; |
---|
311 | 300 | atomic_t session_index; |
---|
.. | .. |
---|
318 | 307 | struct mpp_taskqueue *queue; |
---|
319 | 308 | struct mpp_reset_group *reset_group; |
---|
320 | 309 | /* point to MPP Service */ |
---|
321 | | - struct platform_device *pdev_srv; |
---|
322 | 310 | struct mpp_service *srv; |
---|
323 | 311 | |
---|
| 312 | + /* multi-core data */ |
---|
324 | 313 | struct list_head queue_link; |
---|
325 | | -}; |
---|
| 314 | + s32 core_id; |
---|
326 | 315 | |
---|
327 | | -struct mpp_task; |
---|
| 316 | + /* common per-device procfs */ |
---|
| 317 | + u32 disable; |
---|
| 318 | + u32 timing_check; |
---|
| 319 | +}; |
---|
328 | 320 | |
---|
329 | 321 | struct mpp_session { |
---|
330 | 322 | enum MPP_DEVICE_TYPE device_type; |
---|
.. | .. |
---|
338 | 330 | struct mutex pending_lock; |
---|
339 | 331 | /* task pending list in session */ |
---|
340 | 332 | struct list_head pending_list; |
---|
341 | | - /* lock for session task done list */ |
---|
342 | | - struct mutex done_lock; |
---|
343 | | - /* task done list in session */ |
---|
344 | | - struct list_head done_list; |
---|
345 | 333 | |
---|
346 | | - /* event for session wait thread */ |
---|
347 | | - wait_queue_head_t wait; |
---|
348 | 334 | pid_t pid; |
---|
349 | 335 | atomic_t task_count; |
---|
350 | 336 | atomic_t release_request; |
---|
.. | .. |
---|
370 | 356 | int (*wait_result)(struct mpp_session *session, |
---|
371 | 357 | struct mpp_task_msgs *msgs); |
---|
372 | 358 | void (*deinit)(struct mpp_session *session); |
---|
| 359 | + |
---|
| 360 | + /* max message count */ |
---|
| 361 | + int msgs_cnt; |
---|
| 362 | + struct list_head list_msgs; |
---|
| 363 | + struct list_head list_msgs_idle; |
---|
| 364 | + spinlock_t lock_msgs; |
---|
373 | 365 | }; |
---|
374 | 366 | |
---|
375 | 367 | /* task state in work thread */ |
---|
.. | .. |
---|
387 | 379 | TASK_STATE_ABORT = 9, |
---|
388 | 380 | TASK_STATE_ABORT_READY = 10, |
---|
389 | 381 | TASK_STATE_PROC_DONE = 11, |
---|
| 382 | + |
---|
| 383 | + /* timing debug state */ |
---|
| 384 | + TASK_TIMING_CREATE = 16, |
---|
| 385 | + TASK_TIMING_CREATE_END = 17, |
---|
| 386 | + TASK_TIMING_PENDING = 18, |
---|
| 387 | + TASK_TIMING_RUN = 19, |
---|
| 388 | + TASK_TIMING_TO_SCHED = 20, |
---|
| 389 | + TASK_TIMING_RUN_END = 21, |
---|
| 390 | + TASK_TIMING_IRQ = 22, |
---|
| 391 | + TASK_TIMING_TO_CANCEL = 23, |
---|
| 392 | + TASK_TIMING_ISR = 24, |
---|
| 393 | + TASK_TIMING_FINISH = 25, |
---|
390 | 394 | }; |
---|
391 | 395 | |
---|
392 | 396 | /* The context for the a task */ |
---|
.. | .. |
---|
413 | 417 | struct kref ref; |
---|
414 | 418 | |
---|
415 | 419 | /* record context running start time */ |
---|
416 | | - struct timeval start; |
---|
| 420 | + ktime_t start; |
---|
| 421 | + ktime_t part; |
---|
| 422 | + |
---|
| 423 | + /* debug timing */ |
---|
| 424 | + ktime_t on_create; |
---|
| 425 | + ktime_t on_create_end; |
---|
| 426 | + ktime_t on_pending; |
---|
| 427 | + ktime_t on_run; |
---|
| 428 | + ktime_t on_sched_timeout; |
---|
| 429 | + ktime_t on_run_end; |
---|
| 430 | + ktime_t on_irq; |
---|
| 431 | + ktime_t on_cancel_timeout; |
---|
| 432 | + ktime_t on_isr; |
---|
| 433 | + ktime_t on_finish; |
---|
| 434 | + |
---|
417 | 435 | /* hardware info for current task */ |
---|
418 | 436 | struct mpp_hw_info *hw_info; |
---|
419 | 437 | u32 task_index; |
---|
| 438 | + u32 task_id; |
---|
420 | 439 | u32 *reg; |
---|
| 440 | + /* event for session wait thread */ |
---|
| 441 | + wait_queue_head_t wait; |
---|
| 442 | + |
---|
| 443 | + /* for multi-core */ |
---|
| 444 | + struct mpp_dev *mpp; |
---|
| 445 | + s32 core_id; |
---|
| 446 | + /* hw cycles */ |
---|
| 447 | + u32 hw_cycles; |
---|
421 | 448 | }; |
---|
422 | 449 | |
---|
423 | 450 | struct mpp_taskqueue { |
---|
.. | .. |
---|
432 | 459 | struct list_head session_attach; |
---|
433 | 460 | /* link to session session_link for detached sessions */ |
---|
434 | 461 | struct list_head session_detach; |
---|
435 | | - u32 detach_count; |
---|
| 462 | + atomic_t detach_count; |
---|
436 | 463 | |
---|
| 464 | + atomic_t task_id; |
---|
437 | 465 | /* lock for pending list */ |
---|
438 | 466 | struct mutex pending_lock; |
---|
439 | 467 | struct list_head pending_list; |
---|
.. | .. |
---|
454 | 482 | * device task capacity which is attached to the taskqueue |
---|
455 | 483 | */ |
---|
456 | 484 | u32 task_capacity; |
---|
| 485 | + |
---|
| 486 | + /* multi-core task distribution */ |
---|
| 487 | + atomic_t reset_request; |
---|
| 488 | + struct mpp_dev *cores[MPP_MAX_CORE_NUM]; |
---|
| 489 | + unsigned long core_idle; |
---|
| 490 | + u32 core_id_max; |
---|
| 491 | + u32 core_count; |
---|
| 492 | + unsigned long dev_active_flags; |
---|
457 | 493 | }; |
---|
458 | 494 | |
---|
459 | 495 | struct mpp_reset_group { |
---|
.. | .. |
---|
490 | 526 | struct mutex session_lock; |
---|
491 | 527 | struct list_head session_list; |
---|
492 | 528 | u32 session_count; |
---|
| 529 | + |
---|
| 530 | + /* global timing record flag */ |
---|
| 531 | + u32 timing_en; |
---|
493 | 532 | }; |
---|
494 | 533 | |
---|
495 | 534 | /* |
---|
.. | .. |
---|
580 | 619 | struct mpp_task *task); |
---|
581 | 620 | int mpp_task_finish(struct mpp_session *session, |
---|
582 | 621 | struct mpp_task *task); |
---|
| 622 | +void mpp_task_run_begin(struct mpp_task *task, u32 timing_en, u32 timeout); |
---|
| 623 | +void mpp_task_run_end(struct mpp_task *task, u32 timing_en); |
---|
583 | 624 | int mpp_task_finalize(struct mpp_session *session, |
---|
584 | 625 | struct mpp_task *task); |
---|
585 | 626 | int mpp_task_dump_mem_region(struct mpp_dev *mpp, |
---|
586 | 627 | struct mpp_task *task); |
---|
587 | 628 | int mpp_task_dump_reg(struct mpp_dev *mpp, |
---|
588 | 629 | struct mpp_task *task); |
---|
589 | | -int mpp_task_dump_hw_reg(struct mpp_dev *mpp, |
---|
590 | | - struct mpp_task *task); |
---|
| 630 | +int mpp_task_dump_hw_reg(struct mpp_dev *mpp); |
---|
| 631 | +void mpp_task_dump_timing(struct mpp_task *task, s64 time_diff); |
---|
591 | 632 | |
---|
592 | | -int mpp_session_deinit(struct mpp_session *session); |
---|
| 633 | +void mpp_reg_show(struct mpp_dev *mpp, u32 offset); |
---|
| 634 | +void mpp_reg_show_range(struct mpp_dev *mpp, u32 start, u32 end); |
---|
| 635 | +void mpp_free_task(struct kref *ref); |
---|
| 636 | + |
---|
| 637 | +void mpp_session_deinit(struct mpp_session *session); |
---|
| 638 | +void mpp_session_cleanup_detach(struct mpp_taskqueue *queue, |
---|
| 639 | + struct kthread_work *work); |
---|
| 640 | + |
---|
| 641 | +int mpp_taskqueue_pending_to_run(struct mpp_taskqueue *queue, struct mpp_task *task); |
---|
593 | 642 | |
---|
594 | 643 | int mpp_dev_probe(struct mpp_dev *mpp, |
---|
595 | 644 | struct platform_device *pdev); |
---|
596 | 645 | int mpp_dev_remove(struct mpp_dev *mpp); |
---|
| 646 | +void mpp_dev_shutdown(struct platform_device *pdev); |
---|
597 | 647 | int mpp_dev_register_srv(struct mpp_dev *mpp, struct mpp_service *srv); |
---|
598 | 648 | |
---|
599 | 649 | int mpp_power_on(struct mpp_dev *mpp); |
---|
.. | .. |
---|
613 | 663 | |
---|
614 | 664 | int mpp_time_record(struct mpp_task *task); |
---|
615 | 665 | int mpp_time_diff(struct mpp_task *task); |
---|
| 666 | +int mpp_time_diff_with_hw_time(struct mpp_task *task, u32 clk_hz); |
---|
| 667 | +int mpp_time_part_diff(struct mpp_task *task); |
---|
616 | 668 | |
---|
617 | 669 | int mpp_write_req(struct mpp_dev *mpp, u32 *regs, |
---|
618 | 670 | u32 start_idx, u32 end_idx, u32 en_idx); |
---|
.. | .. |
---|
740 | 792 | return 0; |
---|
741 | 793 | } |
---|
742 | 794 | |
---|
| 795 | +static inline int mpp_pmu_idle_request(struct mpp_dev *mpp, bool idle) |
---|
| 796 | +{ |
---|
| 797 | + if (mpp->skip_idle) |
---|
| 798 | + return 0; |
---|
| 799 | + |
---|
| 800 | + return rockchip_pmu_idle_request(mpp->dev, idle); |
---|
| 801 | +} |
---|
| 802 | + |
---|
| 803 | +static inline struct mpp_dev * |
---|
| 804 | +mpp_get_task_used_device(const struct mpp_task *task, |
---|
| 805 | + const struct mpp_session *session) |
---|
| 806 | +{ |
---|
| 807 | + return task->mpp ? task->mpp : session->mpp; |
---|
| 808 | +} |
---|
| 809 | + |
---|
743 | 810 | #ifdef CONFIG_ROCKCHIP_MPP_PROC_FS |
---|
744 | 811 | struct proc_dir_entry * |
---|
745 | 812 | mpp_procfs_create_u32(const char *name, umode_t mode, |
---|
746 | 813 | struct proc_dir_entry *parent, void *data); |
---|
| 814 | +void mpp_procfs_create_common(struct proc_dir_entry *parent, struct mpp_dev *mpp); |
---|
747 | 815 | #else |
---|
748 | 816 | static inline struct proc_dir_entry * |
---|
749 | 817 | mpp_procfs_create_u32(const char *name, umode_t mode, |
---|
750 | 818 | struct proc_dir_entry *parent, void *data) |
---|
751 | 819 | { |
---|
752 | 820 | return 0; |
---|
| 821 | +} |
---|
| 822 | +void mpp_procfs_create_common(struct proc_dir_entry *parent, struct mpp_dev *mpp) |
---|
| 823 | +{ |
---|
753 | 824 | } |
---|
754 | 825 | #endif |
---|
755 | 826 | |
---|
.. | .. |
---|
770 | 841 | extern struct platform_driver rockchip_iep2_driver; |
---|
771 | 842 | extern struct platform_driver rockchip_jpgdec_driver; |
---|
772 | 843 | extern struct platform_driver rockchip_rkvdec2_driver; |
---|
773 | | -extern struct platform_driver rockchip_vdpp_driver; |
---|
774 | 844 | extern struct platform_driver rockchip_rkvenc2_driver; |
---|
| 845 | +extern struct platform_driver rockchip_av1dec_driver; |
---|
| 846 | +extern struct platform_driver rockchip_av1_iommu_driver; |
---|
| 847 | + |
---|
| 848 | +extern int av1dec_driver_register(struct platform_driver *drv); |
---|
| 849 | +extern void av1dec_driver_unregister(struct platform_driver *drv); |
---|
| 850 | +extern struct bus_type av1dec_bus; |
---|
| 851 | +extern struct platform_driver rockchip_vdpp_driver; |
---|
775 | 852 | |
---|
776 | 853 | #endif |
---|